Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
void load_core_data (loading_ui &ui)
 Loads core dynamic data. More...
 
bool is_core_data_loaded () const
 Returns whether the core data is currently loaded. More...
 
bool check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
 Check if mods can be successfully loaded. More...
 
void load_world_modfiles (loading_ui &ui)
 Loads core data and mods from the active world. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
bool load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
 Load content packs. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_characters ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
cata::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
cata::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
cata::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
cata::optional< tripointlook_around (bool force_3d=false)
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero, bool force_3d=false)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_id gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset ()
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm, bool pump_events=false)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm, bool pump_events=false)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (const point &p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void toggle_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult, Creature *source)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult, Creature *source)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, const point &cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (const point &delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Protected Member Functions

void load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
 Loads dynamic data from the given directory. More...
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
cata::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 795 of file game.h.

795 : int {
796 CHANGE_TAB,
797 QUIT,
798 FIRE, // Who knew, apparently you can do that in list_monsters
799 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 293 of file game.cpp.

293 :
295 scent_ptr( *this ),
298 m( *map_ptr ),
299 u( *u_ptr ),
300 scent( *scent_ptr ),
302 uquit( QUIT_NO ),
303 new_game( false ),
305 mostseen( 0 ),
308 next_npc_id( 1 ),
309 next_mission_id( 1 ),
313 seed( 0 ),
314 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
315{
323 world_generator = std::make_unique<worldfactory>();
324 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
325 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
326}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1049
pimpl< spell_events > spell_events_ptr
Definition: game.h:984
safe_mode_type safe_mode
Definition: game.h:1046
bool safe_mode_warning_logged
Definition: game.h:1060
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:978
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1094
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:1004
event_bus & events()
Definition: game.cpp:2879
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:980
character_id next_npc_id
Definition: game.h:1062
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:982
void reset_light_level()
Definition: game.cpp:3723
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:983
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1051
pimpl< map > map_ptr
Definition: game.h:973
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1077
pimpl< live_view > liveview_ptr
Definition: game.h:975
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:981
pimpl< scent_map > scent_ptr
Definition: game.h:977
timed_event_manager & timed_events
Definition: game.h:992
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1089
int next_mission_id
Definition: game.h:1064
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:1006
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:985
map & m
Definition: game.h:989
avatar & u
Definition: game.h:990
scent_map & scent
Definition: game.h:991
int user_action_counter
Definition: game.h:1083
live_view & liveview
Definition: game.h:976
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1086
pimpl< avatar > u_ptr
Definition: game.h:974
time_point remoteveh_cache_time
Definition: game.h:1070
static void achievement_attained(const achievement *a)
Definition: game.cpp:286
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:28
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 11957 of file game.cpp.

11958{
11959 //If player is sleeping, get a dream from a carried artifact
11960 //Don't need to check that player is sleeping here, that's done before calling
11961 std::list<item *> art_items = g->u.get_artifact_items();
11962 std::vector<item *> valid_arts;
11963 std::vector<std::vector<std::string>>
11964 valid_dreams; // Tracking separately so we only need to check its req once
11965 //Pull the list of dreams
11966 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
11967 for( auto &it : art_items ) {
11968 //Pick only the ones with an applicable dream
11969 const cata::value_ptr<islot_artifact> &art = it->type->artifact;
11970 if( art && art->charge_req != ACR_NULL &&
11971 ( it->ammo_remaining() < it->ammo_capacity() ||
11972 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
11973 add_msg( m_debug, "Checking artifact %s", it->tname() );
11974 if( check_art_charge_req( *it ) ) {
11975 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11976 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
11977 add_msg( m_debug, "Adding met dream from %s", it->tname() );
11978 valid_arts.push_back( it );
11979 valid_dreams.push_back( art->dream_msg_met );
11980 }
11981 } else {
11982 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11983 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
11984 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
11985 valid_arts.push_back( it );
11986 valid_dreams.push_back( art->dream_msg_unmet );
11987 }
11988 }
11989 }
11990 }
11991 if( !valid_dreams.empty() ) {
11992 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
11993 const int selected = rng( 0, valid_arts.size() - 1 );
11994 auto it = valid_arts[selected];
11995 auto msg = random_entry( valid_dreams[selected] );
11996 const std::string &dream = string_format( _( msg ), it->tname() );
11997 add_msg( dream );
11998 } else {
11999 add_msg( m_debug, "Didn't have any dreams, sorry" );
12000 }
12001}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
@ m_debug
Definition: enums.h:271
std::unique_ptr< game > g
Definition: game.cpp:276
bool check_art_charge_req(item &it)
Definition: game.cpp:11660
void add_msg(std::string msg)
Definition: messages.cpp:884
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string format, Args &&...args)
Simple wrapper over string_formatter::parse.
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 11779 of file game.cpp.

11780{
11781 int net_str = 0;
11782 int net_dex = 0;
11783 int net_per = 0;
11784 int net_int = 0;
11785 int net_speed = 0;
11786
11787 for( auto &i : effects ) {
11788 switch( i ) {
11789 case AEP_STR_UP:
11790 net_str += 4;
11791 break;
11792 case AEP_DEX_UP:
11793 net_dex += 4;
11794 break;
11795 case AEP_PER_UP:
11796 net_per += 4;
11797 break;
11798 case AEP_INT_UP:
11799 net_int += 4;
11800 break;
11801 case AEP_ALL_UP:
11802 net_str += 2;
11803 net_dex += 2;
11804 net_per += 2;
11805 net_int += 2;
11806 break;
11807 case AEP_STR_DOWN:
11808 net_str -= 3;
11809 break;
11810 case AEP_DEX_DOWN:
11811 net_dex -= 3;
11812 break;
11813 case AEP_PER_DOWN:
11814 net_per -= 3;
11815 break;
11816 case AEP_INT_DOWN:
11817 net_int -= 3;
11818 break;
11819 case AEP_ALL_DOWN:
11820 net_str -= 2;
11821 net_dex -= 2;
11822 net_per -= 2;
11823 net_int -= 2;
11824 break;
11825
11826 case AEP_SPEED_UP:
11827 net_speed += 20;
11828 break;
11829 case AEP_SPEED_DOWN:
11830 net_speed -= 20;
11831 break;
11832
11833 case AEP_PBLUE:
11834 break; // No message
11835
11836 case AEP_SNAKES:
11837 add_msg( m_warning, _( "Your skin feels slithery." ) );
11838 break;
11839
11840 case AEP_INVISIBLE:
11841 add_msg( m_good, _( "You fade into invisibility!" ) );
11842 break;
11843
11844 case AEP_CLAIRVOYANCE:
11846 add_msg( m_good, _( "You can see through walls!" ) );
11847 break;
11848
11850 add_msg( m_good, _( "You can see through everything!" ) );
11851 break;
11852
11853 case AEP_STEALTH:
11854 add_msg( m_good, _( "Your steps stop making noise." ) );
11855 break;
11856
11857 case AEP_GLOW:
11858 add_msg( _( "A glow of light forms around you." ) );
11859 break;
11860
11861 case AEP_PSYSHIELD:
11862 add_msg( m_good, _( "Your mental state feels protected." ) );
11863 break;
11864
11866 add_msg( m_good, _( "You feel insulated." ) );
11867 break;
11868
11869 case AEP_CARRY_MORE:
11870 add_msg( m_good, _( "Your back feels strengthened." ) );
11871 break;
11872
11873 case AEP_FUN:
11874 add_msg( m_good, _( "You feel a pleasant tingle." ) );
11875 break;
11876
11877 case AEP_HUNGER:
11878 add_msg( m_warning, _( "You feel hungry." ) );
11879 break;
11880
11881 case AEP_THIRST:
11882 add_msg( m_warning, _( "You feel thirsty." ) );
11883 break;
11884
11885 case AEP_EVIL:
11886 add_msg( m_warning, _( "You feel an evil presence…" ) );
11887 break;
11888
11889 case AEP_SCHIZO:
11890 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
11891 break;
11892
11893 case AEP_RADIOACTIVE:
11894 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
11895 break;
11896
11897 case AEP_MUTAGENIC:
11898 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
11899 break;
11900
11901 case AEP_ATTENTION:
11902 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
11903 break;
11904
11905 case AEP_FORCE_TELEPORT:
11906 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
11907 break;
11908
11909 case AEP_MOVEMENT_NOISE:
11910 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
11911 break;
11912
11913 case AEP_BAD_WEATHER:
11914 add_msg( m_warning, _( "You feel storms coming." ) );
11915 break;
11916
11917 case AEP_SICK:
11918 add_msg( m_bad, _( "You feel unwell." ) );
11919 break;
11920
11921 case AEP_SMOKE:
11922 add_msg( m_warning, _( "A cloud of smoke appears." ) );
11923 break;
11924 default:
11925 //Suppress warnings
11926 break;
11927 }
11928 }
11929
11930 std::string stat_info;
11931 if( net_str != 0 ) {
11932 stat_info += string_format( _( "Str %s%d! " ),
11933 ( net_str > 0 ? "+" : "" ), net_str );
11934 }
11935 if( net_dex != 0 ) {
11936 stat_info += string_format( _( "Dex %s%d! " ),
11937 ( net_dex > 0 ? "+" : "" ), net_dex );
11938 }
11939 if( net_int != 0 ) {
11940 stat_info += string_format( _( "Int %s%d! " ),
11941 ( net_int > 0 ? "+" : "" ), net_int );
11942 }
11943 if( net_per != 0 ) {
11944 stat_info += string_format( _( "Per %s%d! " ),
11945 ( net_per > 0 ? "+" : "" ), net_per );
11946 }
11947
11948 if( !stat_info.empty() ) {
11949 add_msg( m_neutral, stat_info );
11950 }
11951
11952 if( net_speed != 0 ) {
11953 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
11954 }
11955}
@ m_good
Definition: enums.h:260
@ m_neutral
Definition: enums.h:267
@ m_info
Definition: enums.h:265
@ m_bad
Definition: enums.h:261
@ m_warning
Definition: enums.h:264
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3174 of file game.cpp.

3175{
3176 draw_callbacks.erase(
3177 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3178 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3179 return cbw.expired();
3180 } ),
3181 draw_callbacks.end()
3182 );
3183 draw_callbacks.emplace_back( cb );
3184 cb->added = true;
3186}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:3139
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:251
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1986 of file game.cpp.

1987{
1988 follower_ids.insert( id );
1989 u.follower_ids.insert( id );
1990}
std::set< character_id > follower_ids
Definition: game.h:1065
std::set< character_id > follower_ids
Definition: player.h:617

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12113 of file game.cpp.

12114{
12115 return Creature_range( *this );
12116}
friend class Creature_range
Definition: game.h:360

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12118 of file game.cpp.

12119{
12120 return monster_range( *this );
12121}
friend class monster_range
Definition: game.h:359

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12123 of file game.cpp.

12124{
12125 return npc_range( *this );
12126}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 12027 of file game.cpp.

12028{
12029 return get_npcs_if( [&]( const npc & guy ) {
12030 if( !guy.is_hallucination() ) {
12031 return guy.is_ally( g->u );
12032 } else {
12033 return false;
12034 }
12035 } );
12036}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:12050
Definition: npc.h:781
bool is_hallucination() const override
Definition: npc.cpp:3260

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1974 of file game.cpp.

1975{
1976 int ret = next_mission_id;
1978 return ret;
1979}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3731 of file game.cpp.

3732{
3734 ++next_npc_id;
3735 return ret;
3736}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1773 of file game.cpp.

1774{
1775 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1776 vehicle *&v = veh.v;
1777 if( v->is_following ) {
1778 v->drive_to_local_target( m.getabs( u.pos() ), true );
1779 } else if( v->is_patrolling ) {
1780 v->autopilot_patrol();
1781 }
1782 }
1783}
const tripoint & pos() const override
Definition: character.cpp:714
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8273
VehicleList get_vehicles()
Definition: map.cpp:237
A vehicle as a whole with all its components.
Definition: vehicle.h:675
void autopilot_patrol()
Definition: vehicle.cpp:701
bool is_following
Definition: vehicle.h:1983
bool is_patrolling
Definition: vehicle.h:1984
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:816

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11446 of file game.cpp.

11447{
11448 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11449 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11450 return;
11451 }
11452 quicksave(); //Driving checks are handled by quicksave()
11453}
time_t last_save_timestamp
Definition: game.h:1067
void quicksave()
Definition: game.cpp:11401

References last_save_timestamp, and quicksave().

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8441 of file game.cpp.

8442{
8443 static const std::string salvage_string = "salvage";
8444 if( u.controlling_vehicle ) {
8445 add_msg( m_info, _( "You can't butcher while driving!" ) );
8446 return;
8447 }
8448
8449 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8450 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8451 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8452 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8453
8454 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8455 if( m.has_flag( "SEALED", u.pos() ) ) {
8456 if( m.sees_some_items( u.pos(), u ) ) {
8457 add_msg( m_info, _( "You can't access the items here." ) );
8458 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8459 add_msg( m_info, no_corpse_msg );
8460 } else {
8461 add_msg( m_info, no_knife_msg );
8462 }
8463 return;
8464 }
8465
8466 const item *first_item_without_tools = nullptr;
8467 // Indices of relevant items
8468 std::vector<map_stack::iterator> corpses;
8469 std::vector<map_stack::iterator> disassembles;
8470 std::vector<map_stack::iterator> salvageables;
8471 map_stack items = m.i_at( u.pos() );
8472 const inventory &crafting_inv = u.crafting_inventory();
8473
8474 // TODO: Properly handle different material whitelists
8475 // TODO: Improve quality of this section
8476 auto salvage_filter = []( item it ) {
8477 const auto usable = it.get_usable_item( salvage_string );
8478 return usable != nullptr;
8479 };
8480
8481 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8482 int salvage_tool_index = INT_MIN;
8483 item *salvage_tool = nullptr;
8484 const salvage_actor *salvage_iuse = nullptr;
8485 if( !salvage_tools.empty() ) {
8486 salvage_tool = salvage_tools.front();
8487 salvage_tool_index = u.get_item_position( salvage_tool );
8488 item *usable = salvage_tool->get_usable_item( salvage_string );
8489 salvage_iuse = dynamic_cast<const salvage_actor *>(
8490 usable->get_use( salvage_string )->get_actor_ptr() );
8491 }
8492
8493 // Reserve capacity for each to hold entire item set if necessary to prevent
8494 // reallocations later on
8495 corpses.reserve( items.size() );
8496 salvageables.reserve( items.size() );
8497 disassembles.reserve( items.size() );
8498
8499 // Split into corpses, disassemble-able, and salvageable items
8500 // It's not much additional work to just generate a corpse list and
8501 // clear it later, but does make the splitting process nicer.
8502 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8503 if( it->is_corpse() ) {
8504 corpses.push_back( it );
8505 } else {
8506 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8507 salvageables.push_back( it );
8508 }
8509 if( crafting::can_disassemble( u, *it, crafting_inv ).success() ) {
8510 disassembles.push_back( it );
8511 } else if( !first_item_without_tools ) {
8512 first_item_without_tools = &*it;
8513 }
8514 }
8515 }
8516
8517 // Clear corpses if butcher and dissect factors are INT_MIN
8518 if( factor == INT_MIN && factorD == INT_MIN ) {
8519 corpses.clear();
8520 }
8521
8522 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8523 if( factor > INT_MIN || factorD > INT_MIN ) {
8524 add_msg( m_info, no_corpse_msg );
8525 } else {
8526 add_msg( m_info, no_knife_msg );
8527 }
8528
8529 if( first_item_without_tools ) {
8530 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8531 // Just for the "You need x to disassemble y" messages
8532 const auto ret = crafting::can_disassemble( u, *first_item_without_tools, crafting_inv );
8533 if( !ret.success() ) {
8534 add_msg( m_info, "%s", ret.c_str() );
8535 }
8536 }
8537 return;
8538 }
8539
8540 Creature *hostile_critter = is_hostile_very_close();
8541 if( hostile_critter != nullptr ) {
8542 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8543 hostile_critter->disp_name() ) ) {
8544 return;
8545 }
8546 }
8547
8548 // Magic indices for special butcher options
8549 enum : int {
8550 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8551 MULTIBUTCHER,
8552 MULTIDISASSEMBLE_ONE,
8553 MULTIDISASSEMBLE_ALL,
8554 NUM_BUTCHER_ACTIONS
8555 };
8556 // What are we butchering (i.e.. which vector to pick indices from)
8557 enum {
8558 BUTCHER_CORPSE,
8559 BUTCHER_DISASSEMBLE,
8560 BUTCHER_SALVAGE,
8561 BUTCHER_OTHER // For multisalvage etc.
8562 } butcher_select = BUTCHER_CORPSE;
8563 // Index to std::vector of iterators...
8564 int indexer_index = 0;
8565
8566 // Generate the indexed stacks so we can display them nicely
8567 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8568 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8569 // Always ask before cutting up/disassembly, but not before butchery
8570 size_t ret = 0;
8571 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8572 uilist kmenu;
8573 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8574
8575 size_t i = 0;
8576 // Add corpses, disassembleables, and salvagables to the UI
8577 add_corpses( kmenu, corpses, i );
8578 add_disassemblables( kmenu, disassembly_stacks, i );
8579 if( salvage_iuse && !salvageables.empty() ) {
8580 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8581 }
8582
8583 if( corpses.size() > 1 ) {
8584 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8585 }
8586 if( disassembles.size() > 1 ) {
8587 int time_to_disassemble = 0;
8588 int time_to_disassemble_all = 0;
8589 for( const auto &stack : disassembly_stacks ) {
8590 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8591 time_to_disassemble += time;
8592 time_to_disassemble_all += time * stack.second;
8593 }
8594
8595 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8596 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8597 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8598 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8599 }
8600 if( salvage_iuse && salvageables.size() > 1 ) {
8601 int time_to_salvage = 0;
8602 for( const auto &stack : salvage_stacks ) {
8603 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8604 }
8605
8606 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8607 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8608 }
8609
8610 kmenu.query();
8611
8612 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8613 return;
8614 }
8615
8616 ret = static_cast<size_t>( kmenu.ret );
8617 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8618 butcher_select = BUTCHER_OTHER;
8619 indexer_index = ret;
8620 } else if( ret < corpses.size() ) {
8621 butcher_select = BUTCHER_CORPSE;
8622 indexer_index = ret;
8623 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8624 butcher_select = BUTCHER_DISASSEMBLE;
8625 indexer_index = ret - corpses.size();
8626 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8627 butcher_select = BUTCHER_SALVAGE;
8628 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8629 } else {
8630 debugmsg( "Invalid butchery index: %d", ret );
8631 return;
8632 }
8633 }
8634
8635 if( !u.has_morale_to_craft() ) {
8636 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8637 add_msg( m_info,
8638 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8639 } else {
8640 add_msg( m_info,
8641 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8642 }
8643 return;
8644 }
8645 const auto helpers = u.get_crafting_helpers( 3 );
8646 for( const npc *np : helpers ) {
8647 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8648 }
8649 switch( butcher_select ) {
8650 case BUTCHER_OTHER:
8651 switch( indexer_index ) {
8652 case MULTISALVAGE:
8653 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8654 break;
8655 case MULTIBUTCHER:
8656 butcher_submenu( corpses );
8657 for( map_stack::iterator &it : corpses ) {
8658 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8659 }
8660 break;
8661 case MULTIDISASSEMBLE_ONE:
8662 crafting::disassemble_all( u, false );
8663 break;
8664 case MULTIDISASSEMBLE_ALL:
8666 break;
8667 default:
8668 debugmsg( "Invalid butchery type: %d", indexer_index );
8669 return;
8670 }
8671 break;
8672 case BUTCHER_CORPSE: {
8673 butcher_submenu( corpses, indexer_index );
8674 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8675 }
8676 break;
8677 case BUTCHER_DISASSEMBLE: {
8678 // Pick index of first item in the disassembly stack
8679 item *const target = &*disassembly_stacks[indexer_index].first;
8681 }
8682 break;
8683 case BUTCHER_SALVAGE: {
8684 if( !salvage_iuse || !salvage_tool ) {
8685 debugmsg( "null salve_iuse or salvage_tool" );
8686 } else {
8687 // Pick index of first item in the salvage stack
8688 item *const target = &*salvage_stacks[indexer_index].first;
8689 item_location item_loc( map_cursor( u.pos() ), target );
8690 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8691 }
8692 }
8693 break;
8694 }
8695}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:228
player_activity activity
Definition: character.h:1516
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2407
bool has_morale_to_craft() const
Definition: crafting.cpp:335
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:553
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9194
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3745
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
Definition: item.h:177
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7833
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7807
Definition: map.h:105
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2293
map_stack i_at(const tripoint &p)
Definition: map.cpp:4090
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4736
std::vector< item_location > targets
std::vector< npc * > get_crafting_helpers(size_t max=0) const
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
Definition: crafting.cpp:2308
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:59
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:962
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:942
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8291
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8249
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8270
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8202
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8237
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:838
ret_val< bool > can_disassemble(const Character &who, const item &obj, const inventory &inv)
Check if character can disassemble an item using the given crafting inventory.
Definition: crafting.cpp:1875
bool disassemble(avatar &you)
Prompt for an item to disassemble, then start activity.
Definition: crafting.cpp:2074
bool disassemble_all(avatar &you, bool recursively)
Start an activity to disassemble all items in avatar's square.
Definition: crafting.cpp:2085
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:314
string_id< quality > quality_id
Definition: type_id.h:181

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), crafting::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, crafting::disassemble(), crafting::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1353 of file game.cpp.

1354{
1355 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1357 return;
1358 }
1359 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1360 const int light_sight_range = u.sight_range( g_light_level );
1361 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1362
1363 // The maximal offset will leave at least this many tiles
1364 // between the PC and the edge of the main window.
1365 static const int border_range = 2;
1366 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1367 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1368
1369 // velocity at or below this results in no offset at all
1370 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1371 // velocity at or above this results in maximal offset
1372 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1374 float velocity = veh->velocity;
1375 rl_vec2d offset = veh->move_vec();
1376 if( !veh->skidding && veh->player_in_control( u ) &&
1377 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1378 // Use the cruise controlled velocity, but only if
1379 // it is not too different from the actual velocity.
1380 // The actual velocity changes too often (see above slowdown).
1381 // Using it makes would make the offset change far too often.
1382 offset = veh->face_vec();
1383 velocity = veh->cruise_velocity;
1384 }
1385 float rel_offset;
1386 if( std::fabs( velocity ) < min_offset_vel ) {
1387 rel_offset = 0;
1388 } else if( std::fabs( velocity ) > max_offset_vel ) {
1389 rel_offset = ( velocity > 0 ) ? 1 : -1;
1390 } else {
1391 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1392 }
1393 // Squeeze into the corners, by making the offset vector longer,
1394 // the PC is still in view as long as both offset.x and
1395 // offset.y are <= 1
1396 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1397 offset.y /= std::fabs( offset.x );
1398 offset.x = ( offset.x > 0 ) ? +1 : -1;
1399 } else if( std::fabs( offset.y ) > 0.2 ) {
1400 offset.x /= std::fabs( offset.y );
1401 offset.y = offset.y > 0 ? +1 : -1;
1402 }
1403 offset.x *= rel_offset;
1404 offset.y *= rel_offset;
1405 offset.x *= max_offset.x;
1406 offset.y *= max_offset.y;
1407 // [ ----@---- ] sight=6
1408 // [ --@------ ] offset=2
1409 // [ -@------# ] offset=3
1410 // can see sights square in every direction, total visible area is
1411 // (2*sight+1)x(2*sight+1), but the window is only
1412 // getmaxx(w_terrain) x getmaxy(w_terrain)
1413 // The area outside of the window is maxoff (sight-getmax/2).
1414 // If that value is <= 0, the whole visible area fits the window.
1415 // don't apply the view offset at all.
1416 // If the offset is > maxoff, only apply at most maxoff, everything
1417 // above leads to invisible area in front of the car.
1418 // It will display (getmax/2+offset) squares in one direction and
1419 // (getmax/2-offset) in the opposite direction (centered on the PC).
1420 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1421 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1422 if( maxoff.x <= 0 ) {
1423 offset.x = 0;
1424 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1425 offset.x = maxoff.x;
1426 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1427 offset.x = -maxoff.x;
1428 }
1429 if( maxoff.y <= 0 ) {
1430 offset.y = 0;
1431 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1432 offset.y = maxoff.y;
1433 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1434 offset.y = -maxoff.y;
1435 }
1436
1437 // Turn the offset into a vector that increments the offset toward the desired position
1438 // instead of setting it there instantly, should smooth out jerkiness.
1439 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1440
1441 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1442 ( offset_difference.y < 0 ) ? -1 : 1 );
1443 // Shift the current offset in the direction of the calculated offset by one tile
1444 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1445 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1446 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1447 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1448 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1449
1450 set_driving_view_offset( point( offset.x, offset.y ) );
1451}
int posz() const override
Definition: character.h:785
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:719
point driving_view_offset
Definition: game.h:1023
catacurses::window w_terrain
Definition: game.h:1013
void set_driving_view_offset(const point &p)
Definition: game.cpp:1710
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3717
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:1999
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:277
int velocity
Definition: vehicle.h:1918
int cruise_velocity
Definition: vehicle.h:1920
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1335
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:68
static constexpr point point_zero
Definition: point.h:274
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1812 of file game.cpp.

1813{
1815 if( u.has_distant_destination() ) {
1816 if( cancel_auto_move( u, text ) ) {
1817 return true;
1818 } else {
1820 return false;
1821 }
1822 }
1824 return false;
1825 }
1826 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1827 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1829
1830 const auto &action = query_popup()
1831 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1832 .message( force_uc ?
1833 pgettext( "cancel_activity_or_ignore_query",
1834 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1835 pgettext( "cancel_activity_or_ignore_query",
1836 "<color_light_red>%s %s</color>" ),
1837 text, u.activity.get_stop_phrase() )
1838 .option( "YES", allow_key )
1839 .option( "NO", allow_key )
1840 .option( "MANAGER", allow_key )
1841 .option( "IGNORE", allow_key )
1842 .query()
1843 .action;
1844
1845 if( action == "YES" ) {
1847 return true;
1848 }
1849 if( action == "IGNORE" ) {
1851 for( auto &activity : u.backlog ) {
1852 activity.ignore_distraction( type );
1853 }
1854 }
1855 if( action == "MANAGER" ) {
1858 return true;
1859 }
1860
1863
1864 return false;
1865}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9237
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1517
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:545
static const input_event_filter disallow_lower_case
Definition: input.h:544
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
distraction_manager::distraction_manager_gui & get_distraction_manager()
@ type
Definition: enums.h:75
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1799
void redraw()
Invalidate the top window and redraw all invalidated windows.
Definition: ui_manager.cpp:389
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), get_distraction_manager(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), distraction_manager::distraction_manager_gui::show(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1867 of file game.cpp.

1868{
1870 if( u.has_distant_destination() ) {
1871 if( cancel_auto_move( u, text ) ) {
1872 return true;
1873 } else {
1875 return false;
1876 }
1877 }
1878 if( !u.activity ) {
1879 return false;
1880 }
1881 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1885 return true;
1886 }
1887 return false;
1888}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9269

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1785 of file game.cpp.

1787{
1788 //spawn the corpse, rotten by a part of the duration
1790 catch_duration ) ) );
1791 if( u.sees( pos ) ) {
1792 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1793 }
1794 //quietly kill the caught
1795 fish->no_corpse_quiet = true;
1796 fish->die( p );
1797}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:507
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4235
bool no_corpse_quiet
Definition: monster.h:485
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2267
const mtype * type
Definition: monster.h:481
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:3973
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 394 of file npctalk.cpp.

395{
396 int volume = g->u.get_shout_volume();
397
398 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
399 // TODO: Get rid of the z-level check when z-level vision gets "better"
400 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
401 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
402 } );
403 const int available_count = available.size();
404 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
405 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
406 } );
407 const int follower_count = followers.size();
408 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
409 return guy.mission == NPC_MISSION_GUARD_ALLY &&
410 guy.companion_mission_role_id != "FACTION_CAMP" &&
411 guy.can_hear( u.pos(), volume );
412 } );
413 const int guard_count = guards.size();
414
415 if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
416 g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
417 g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
418 return;
419 }
420 std::vector<vehicle *> animal_vehicles;
421 std::vector<vehicle *> following_vehicles;
422 std::vector<vehicle *> magic_vehicles;
423 std::vector<vehicle *> magic_following_vehicles;
424 for( auto &veh : g->m.get_vehicles() ) {
425 auto &v = veh.v;
426 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
427 animal_vehicles.push_back( v );
428 if( v->is_following ) {
429 following_vehicles.push_back( v );
430 }
431 }
432 if( v->magic ) {
433 for( const vpart_reference &vp : v->get_all_parts() ) {
434 const vpart_info &vpi = vp.info();
435 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
436 magic_vehicles.push_back( v );
437 if( v->is_following ) {
438 magic_following_vehicles.push_back( v );
439 }
440 break;
441 }
442 }
443 }
444 }
445
446 uilist nmenu;
447 nmenu.text = std::string( _( "What do you want to do?" ) );
448
449 if( !available.empty() ) {
450 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
451 string_format( _( "Talk to %s" ), available.front()->name ) :
452 _( "Talk to…" )
453 );
454 }
455 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
456 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
457 if( !animal_vehicles.empty() ) {
459 _( "Whistle at your animals pulling vehicles to follow you." ) );
460 }
461 if( !magic_vehicles.empty() ) {
463 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
464 }
465 if( !magic_following_vehicles.empty() ) {
467 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
468 }
469 if( !following_vehicles.empty() ) {
471 _( "Whistle at your animals pulling vehicles to stop following you." ) );
472 }
473 if( !guards.empty() ) {
474 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
475 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
476 _( "Tell someone to follow…" )
477 );
478 }
479 if( !followers.empty() ) {
480 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
481 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
482 _( "Tell someone to guard…" )
483 );
484 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
485 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
486 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
487 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
488 _( "Tell everyone on your team to prepare for danger" ) );
489 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
490 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
491 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
492 }
493 std::string message;
494 std::string yell_msg;
495 bool is_order = true;
496 nmenu.query();
497
498 if( nmenu.ret < 0 ) {
499 return;
500 }
501
502 switch( nmenu.ret ) {
503 case NPC_CHAT_TALK: {
504 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
505 if( npcselect < 0 ) {
506 return;
507 }
508 available[npcselect]->talk_to_u();
509 break;
510 }
511 case NPC_CHAT_YELL:
512 is_order = false;
513 message = _( "loudly." );
514 break;
515 case NPC_CHAT_SENTENCE: {
516 std::string popupdesc = _( "Enter a sentence to yell" );
518 popup.title( _( "Yell a sentence" ) )
519 .width( 64 )
520 .description( popupdesc )
521 .identifier( "sentence" )
522 .max_length( 128 )
523 .query();
524 yell_msg = popup.text();
525 is_order = false;
526 break;
527 }
528 case NPC_CHAT_GUARD: {
529 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
530 if( npcselect < 0 ) {
531 return;
532 }
533 if( npcselect == follower_count ) {
534 for( npc *them : followers ) {
536 }
537 yell_msg = _( "Everyone guard here!" );
538 } else {
539 talk_function::assign_guard( *followers[npcselect] );
540 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
541 }
542 break;
543 }
544 case NPC_CHAT_FOLLOW: {
545 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
546 if( npcselect < 0 ) {
547 return;
548 }
549 if( npcselect == guard_count ) {
550 for( npc *them : guards ) {
552 }
553 yell_msg = _( "Everyone follow me!" );
554 } else {
555 talk_function::stop_guard( *guards[npcselect] );
556 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
557 }
558 break;
559 }
560 case NPC_CHAT_AWAKE:
561 for( npc *them : followers ) {
562 talk_function::wake_up( *them );
563 }
564 yell_msg = _( "Stay awake!" );
565 break;
566 case NPC_CHAT_MOUNT:
567 for( npc *them : followers ) {
568 if( them->has_effect( effect_riding ) ) {
569 continue;
570 }
572 }
573 yell_msg = _( "Mount up!" );
574 break;
576 for( npc *them : followers ) {
577 if( them->has_effect( effect_riding ) ) {
578 them->npc_dismount();
579 }
580 }
581 yell_msg = _( "Dismount!" );
582 break;
583 case NPC_CHAT_DANGER:
584 for( npc *them : followers ) {
585 them->rules.set_danger_overrides();
586 }
587 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
588 "and don't open any doors." );
589 break;
591 for( npc *p : followers ) {
593 }
594 yell_msg = _( "As you were." );
595 break;
596 case NPC_CHAT_ORDERS:
597 npc_temp_orders_menu( followers );
598 break;
601 break;
604 break;
607 break;
610 break;
611 default:
612 return;
613 }
614
615 if( !yell_msg.empty() ) {
616 message = string_format( "\"%s\"", yell_msg );
617 }
618 if( !message.empty() ) {
619 add_msg( _( "You yell %s" ), message );
620 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
621 }
622
623 u.moves -= 100;
624}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:546
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7729
bool can_hear(const tripoint &source, int volume) const
int moves
Definition: creature.h:569
std::string companion_mission_role_id
Definition: npc.h:1318
npc_mission mission
Definition: npc.h:1325
bool is_player_ally() const
Definition: npc.cpp:1987
bool is_following() const
Definition: npc.cpp:2018
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:408
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4126
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:187
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:220
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:377
static void tell_veh_stop_following()
Definition: npctalk.cpp:340
static void assign_veh_to_follow()
Definition: npctalk.cpp:351
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:252
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:200
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:214
@ NPC_CHAT_YELL
Definition: npctalk.cpp:195
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:198
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:197
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:201
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:211
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:203
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:196
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:210
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:202
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:199
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:212
@ NPC_CHAT_TALK
Definition: npctalk.cpp:194
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:213
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:361
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_mod_data()

bool game::check_mod_data ( const std::vector< mod_id > &  opts,
loading_ui ui 
)

Check if mods can be successfully loaded.

Parameters
optscheck specific mods (or all if unspecified)
Returns
whether all mods were successfully loaded

Definition at line 353 of file game.cpp.

354{
355 auto &tree = world_generator->get_mod_manager().get_tree();
356
357 // deduplicated list of mods to check
358 std::set<mod_id> check( opts.begin(), opts.end() );
359
360 // if no specific mods specified check all non-obsolete mods
361 if( check.empty() ) {
362 for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
363 if( !e->obsolete ) {
364 check.emplace( e );
365 }
366 }
367 }
368
369 if( check.empty() ) {
370 world_generator->set_active_world( nullptr );
371 world_generator->init();
372 const std::vector<mod_id> mods_empty;
373 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
374 world_generator->set_active_world( test_world );
375
376 // if no loadable mods then test core data only
377 try {
380 } catch( const std::exception &err ) {
381 std::cerr << "Error loading data from json: " << err.what() << std::endl;
382 }
383
384 std::string world_name = world_generator->active_world->world_name;
385 world_generator->delete_world( world_name, true );
386
389 }
390
391 for( const auto &e : check ) {
392 world_generator->set_active_world( nullptr );
393 world_generator->init();
394 const std::vector<mod_id> mods_empty;
395 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
396 if( !test_world ) {
397 std::cerr << "Failed to generate test world." << std::endl;
398 return false;
399 }
400 world_generator->set_active_world( test_world );
401
402 if( !e.is_valid() ) {
403 std::cerr << "Unknown mod: " << e.str() << std::endl;
404 return false;
405 }
406
407 const MOD_INFORMATION &mod = *e;
408
409 if( !tree.is_available( mod.ident ) ) {
410 std::cerr << "Missing dependencies: " << mod.name() << "\n"
411 << tree.get_node( mod.ident )->s_errors() << std::endl;
412 return false;
413 }
414
415 std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
416
417 try {
419
420 // Load any dependencies
421 for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
422 load_data_from_dir( dep->path, dep->ident.str(), ui );
423 }
424
425 // Load mod itself
426 load_data_from_dir( mod.path, mod.ident.str(), ui );
428 } catch( const std::exception &err ) {
429 std::cerr << "Error loading data: " << err.what() << std::endl;
430 }
431
432 std::string world_name = world_generator->active_world->world_name;
433 world_generator->delete_world( world_name, true );
434
437 }
438 return true;
439}
void finalize_loaded_data(loading_ui &ui)
Called to finalize the loaded data.
Definition: init.cpp:636
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:114
void load_data_from_dir(const std::string &path, const std::string &src, loading_ui &ui)
Loads dynamic data from the given directory.
Definition: game.cpp:455
void load_core_data(loading_ui &ui)
Loads core dynamic data.
Definition: game.cpp:446
void reset()
Delete all buffered submaps.
Definition: mapbuffer.cpp:49
int check(unformattable)
Definition: fmtlib_core.h:1610
Definition: overmap_ui.h:17
overmapbuffer overmap_buffer

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6162 of file game.cpp.

6163{
6164 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6165}
static zone_manager & get_manager()
Definition: clzones.cpp:126
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 8697 of file game.cpp.

8698{
8699 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
8700 // Already warned player since safe_mode_warning_logged is set.
8701 return false;
8702 }
8703
8704 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
8705 if( !msg_ignore.empty() ) {
8706 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
8707 // Operate on a wide-char basis to prevent corrupted multi-byte string
8708 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
8709 msg_ignore = wstr_to_utf8( msg_ignore_wide );
8710 }
8711
8713 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
8714 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
8716 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
8717 } else {
8719 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
8720 }
8722 return false;
8723 }
8724 if( safe_mode != SAFE_MODE_STOP ) {
8725 return true;
8726 }
8727 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
8728 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
8729 return true;
8730 }
8731 // Monsters around and we don't want to run
8732 std::string spotted_creature_name;
8733 const monster_visible_info &mon_visible = u.get_mon_visible();
8734 const auto &new_seen_mon = mon_visible.new_seen_mon;
8735
8736 if( new_seen_mon.empty() ) {
8737 // naming consistent with code in game::mon_info
8738 spotted_creature_name = _( "a survivor" );
8740 } else {
8741 spotted_creature_name = new_seen_mon.back()->name();
8742 get_safemode().lastmon_whitelist = spotted_creature_name;
8743 }
8744
8745 std::string whitelist;
8746 if( !get_safemode().empty() ) {
8747 whitelist = string_format( _( " or %s to whitelist the monster" ),
8749 }
8750
8751 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
8753 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
8754 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
8756 return false;
8757}
std::string press_x(action_id act)
Definition: action.cpp:457
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:221
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:223
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:215
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:103
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1179
int get_int_base() const override
Definition: avatar.cpp:1016
monster_visible_info & get_mon_visible()
Definition: avatar.h:217
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:288
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:293
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:41

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6157 of file game.cpp.

6158{
6159 return zone_manager::get_manager().has( type, m.getabs( where ) );
6160}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 1049 of file game.cpp.

1050{
1051 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1052 // Put (non-hallucinations) into the overmap so they are not lost.
1053 for( monster &critter : all_monsters() ) {
1054 despawn_monster( critter );
1055 }
1056 // Reset NPC factions and disposition
1058 // Save the factions', missions and set the NPC's overmap coordinates
1059 // Npcs are saved in the overmap.
1060 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
1061 // save artifacts.
1063
1064 // and the overmap, and the local map.
1065 save_maps(); //Omap also contains the npcs who need to be saved.
1066 }
1067
1068 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1069 std::vector<std::string> vRip;
1070
1071 int iMaxWidth = 0;
1072 int iNameLine = 0;
1073 int iInfoLine = 0;
1074
1077 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
1078 vRip.emplace_back( " _______ ___" );
1079 vRip.emplace_back( " < `/ |" );
1080 vRip.emplace_back( " > _ _ (" );
1081 vRip.emplace_back( " | |_) | |_) |" );
1082 vRip.emplace_back( " | | \\ | | |" );
1083 vRip.emplace_back( " ______.__%_| |_________ __" );
1084 vRip.emplace_back( " _/ \\| |" );
1085 iNameLine = vRip.size();
1086 vRip.emplace_back( "| <" );
1087 vRip.emplace_back( "| |" );
1088 iMaxWidth = utf8_width( vRip.back() );
1089 vRip.emplace_back( "| |" );
1090 vRip.emplace_back( "|_____.-._____ __/|_________|" );
1091 vRip.emplace_back( " | |" );
1092 iInfoLine = vRip.size();
1093 vRip.emplace_back( " | |" );
1094 vRip.emplace_back( " | <" );
1095 vRip.emplace_back( " | |" );
1096 vRip.emplace_back( " | _ |" );
1097 vRip.emplace_back( " |__/ |" );
1098 vRip.emplace_back( " % / `--. |%" );
1099 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
1100 vRip.emplace_back( " `\\%`@| |@@%@%%" );
1101 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1102 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1103
1104 } else {
1105 vRip.emplace_back( " _______ ___" );
1106 vRip.emplace_back( " | \\/ |" );
1107 vRip.emplace_back( " | |" );
1108 vRip.emplace_back( " | |" );
1109 iInfoLine = vRip.size();
1110 vRip.emplace_back( " | |" );
1111 vRip.emplace_back( " | |" );
1112 vRip.emplace_back( " | |" );
1113 vRip.emplace_back( " | |" );
1114 vRip.emplace_back( " | <" );
1115 vRip.emplace_back( " | _ |" );
1116 vRip.emplace_back( " |__/ |" );
1117 vRip.emplace_back( " ______.__%_| |__________ _" );
1118 vRip.emplace_back( " _/ \\| \\" );
1119 iNameLine = vRip.size();
1120 vRip.emplace_back( "| <" );
1121 vRip.emplace_back( "| |" );
1122 iMaxWidth = utf8_width( vRip.back() );
1123 vRip.emplace_back( "| |" );
1124 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1125 vRip.emplace_back( " % / `_-. _ |%" );
1126 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1127 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1128 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1129 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1130 }
1131 } else {
1132 vRip.emplace_back( R"( _________ ____ )" );
1133 vRip.emplace_back( R"( _/ `/ \_ )" );
1134 vRip.emplace_back( R"( _/ _ _ \_. )" );
1135 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1136 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1137 vRip.emplace_back( R"( _/ \_ )" );
1138 vRip.emplace_back( R"(| |)" );
1139 iNameLine = vRip.size();
1140 vRip.emplace_back( R"( ) < )" );
1141 vRip.emplace_back( R"(| |)" );
1142 vRip.emplace_back( R"(| |)" );
1143 vRip.emplace_back( R"(| _ |)" );
1144 vRip.emplace_back( R"(|__/ |)" );
1145 iMaxWidth = utf8_width( vRip.back() );
1146 vRip.emplace_back( R"( / `--. |)" );
1147 vRip.emplace_back( R"(| ( )" );
1148 iInfoLine = vRip.size();
1149 vRip.emplace_back( R"(| |)" );
1150 vRip.emplace_back( R"(| |)" );
1151 vRip.emplace_back( R"(| % . |)" );
1152 vRip.emplace_back( R"(| @` %% |)" );
1153 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1154 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1155 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1156 }
1157
1158 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1159 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1160
1162 point( iOffsetX, iOffsetY ) );
1163 draw_border( w_rip );
1164
1165 sfx::do_player_death_hurt( g->u, true );
1170
1171 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1172 size_t iX = 0;
1173 const char *str = vRip[iY].data();
1174 for( int slen = vRip[iY].size(); slen > 0; ) {
1175 const uint32_t cTemp = UTF8_getch( &str, &slen );
1176 if( cTemp != U' ' ) {
1177 nc_color ncColor = c_light_gray;
1178
1179 if( cTemp == U'%' ) {
1180 ncColor = c_green;
1181
1182 } else if( cTemp == U'_' || cTemp == U'|' ) {
1183 ncColor = c_white;
1184
1185 } else if( cTemp == U'@' ) {
1186 ncColor = c_brown;
1187
1188 } else if( cTemp == U'*' ) {
1189 ncColor = c_red;
1190 }
1191
1192 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1193 cTemp );
1194 }
1195 iX += mk_wcwidth( cTemp );
1196 }
1197 }
1198
1199 std::string sTemp;
1200
1201 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1202
1204 const int minutes = to_minutes<int>( survived ) % 60;
1205 const int hours = to_hours<int>( survived ) % 24;
1206 const int days = to_days<int>( survived );
1207
1208 if( days > 0 ) {
1209 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1210 } else if( hours > 0 ) {
1211 sTemp = string_format( "%dh %dm", hours, minutes );
1212 } else {
1213 sTemp = string_format( "%dm", minutes );
1214 }
1215
1216 center_print( w_rip, iInfoLine++, c_white, sTemp );
1217
1218 const int iTotalKills = get_kill_tracker().monster_kill_count();
1219
1220 sTemp = _( "Kills:" );
1221 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1222 ( sTemp + " " ) );
1223 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1224
1225 sTemp = _( "In memory of:" );
1226 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1228 sTemp );
1229
1230 sTemp = u.name;
1231 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1232 sTemp );
1233
1234 sTemp = _( "Last Words:" );
1235 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1237 sTemp );
1238
1239 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1240 std::string sLastWords = string_input_popup()
1241 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1242 .max_length( iMaxWidth - 4 - 1 )
1243 .query_string();
1244 death_screen();
1245 const bool is_suicide = uquit == QUIT_SUICIDE;
1246 events().send<event_type::game_over>( is_suicide, sLastWords );
1247 // Struck the save_player_data here to forestall Weirdness
1248 std::string char_filename = generate_memorial_filename( u.name );
1249 move_save_to_graveyard( char_filename );
1250 write_memorial_file( char_filename, sLastWords );
1251 memorial().clear();
1252 std::vector<std::string> characters = list_active_characters();
1253 // remove current player from the active characters list, as they are dead
1254 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1255 characters.end(), u.name );
1256 if( curchar != characters.end() ) {
1257 characters.erase( curchar );
1258 }
1259
1260 if( characters.empty() ) {
1261 bool queryDelete = false;
1262 bool queryReset = false;
1263
1264 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1265 bool decided = false;
1266 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1267 "will not all reset when starting a new character in an "
1268 "already-played world. This can lead to some strange "
1269 "behavior.\n\n"
1270 "Are you sure you wish to keep this world?"
1271 );
1272
1273 while( !decided ) {
1274 uilist smenu;
1275 smenu.allow_cancel = false;
1276 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1277 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1278 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1279 smenu.query();
1280
1281 switch( smenu.ret ) {
1282 case 0:
1283 queryReset = true;
1284 decided = true;
1285 break;
1286 case 1:
1287 queryDelete = true;
1288 decided = true;
1289 break;
1290 case 2:
1291 decided = query_yn( buffer );
1292 break;
1293 }
1294 }
1295 }
1296
1297 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1298 world_generator->delete_world( world_generator->active_world->world_name, true );
1299
1300 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1301 world_generator->delete_world( world_generator->active_world->world_name, false );
1302 }
1303 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1304 std::string tmpmessage;
1305 for( auto &character : characters ) {
1306 tmpmessage += "\n ";
1307 tmpmessage += character;
1308 }
1309 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1310 }
1311 if( gamemode ) {
1312 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1313 }
1314 }
1315
1316 //Reset any offset due to driving
1318
1319 //clear all sound channels
1325
1326 MAPBUFFER.reset();
1328
1329#if defined(__ANDROID__)
1330 quick_shortcuts_map.clear();
1331#endif
1332 return true;
1333}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1504
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2575
bool save_maps()
Definition: game.cpp:2840
std::unique_ptr< special_game > gamemode
Definition: game.h:1081
void death_screen()
Definition: game.cpp:2524
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12118
bool save_factions_missions_npcs()
Definition: game.cpp:2826
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11143
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:987
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:2939
std::vector< std::string > list_active_characters()
Returns a list of currently active character saves.
Definition: game.cpp:2924
bool save_artifacts()
Definition: game.cpp:2834
memorial_logger & memorial()
Definition: game.cpp:2889
void reset_npc_dispositions()
Definition: game.cpp:2798
int monster_kill_count() const
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
string_input_popup & window(const catacurses::window &w, const point &start, int endx)
Set the window area where to display the input text.
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:1022
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, const point &begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1633
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1618
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1617
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, const point &p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2035
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2043
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void mvwputch(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:477
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4193 of file game.cpp.

4194{
4195 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4196 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4197 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4198
4199 bool npc_is_dead = false;
4200 // can't use all_npcs as that does not include dead ones
4201 for( const auto &n : active_npc ) {
4202 if( n->is_dead() ) {
4203 n->die( nullptr ); // make sure this has been called to create corpses etc.
4204 npc_is_dead = true;
4205 }
4206 }
4207
4208 if( monster_is_dead ) {
4209 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4210 critter_tracker->remove_dead();
4211 }
4212
4213 if( npc_is_dead ) {
4214 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4215 if( ( *it )->is_dead() ) {
4216 remove_npc_follower( ( *it )->getID() );
4217 overmap_buffer.remove_npc( ( *it )->getID() );
4218 it = active_npc.erase( it );
4219 } else {
4220 it++;
4221 }
4222 }
4223 }
4224
4225 critter_died = false;
4226}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1992
pimpl< Creature_tracker > critter_tracker
Definition: game.h:999
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1063
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1075
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 4869 of file game.cpp.

4870{
4871 critter_tracker->clear();
4872}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5315 of file game.cpp.

5316{
5317 static const itype_id fuel_type_animal( "animal" );
5318 int veh_part = -1;
5319 vehicle *veh = remoteveh();
5320 if( veh == nullptr ) {
5321 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5322 veh = &vp->vehicle();
5323 veh_part = vp->part_index();
5324 }
5325 }
5326 if( veh != nullptr && veh->player_in_control( u ) &&
5327 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5328 veh->use_controls( u.pos() );
5329 } else if( veh && veh->player_in_control( u ) &&
5330 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5331 u.controlling_vehicle = false;
5332 add_msg( m_info, _( "You let go of the reins." ) );
5333 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5334 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5335 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5336 u.in_vehicle ) {
5337 if( u.has_trait( trait_WAYFARER ) ) {
5338 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5339 return;
5340 }
5341 if( !veh->interact_vehicle_locked() ) {
5342 veh->handle_potential_theft( dynamic_cast<player &>( u ) );
5343 return;
5344 }
5345 if( veh->engine_on ) {
5346 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5347 return;
5348 }
5349 u.controlling_vehicle = true;
5350 add_msg( _( "You take control of the %s." ), veh->name );
5351 } else {
5352 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5353 return;
5354 }
5355 veh->start_engines( true );
5356 }
5357 } else { // Start looking for nearby vehicle controls.
5358 int num_valid_controls = 0;
5359 cata::optional<tripoint> vehicle_position;
5360 cata::optional<vpart_reference> vehicle_controls;
5361 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5362 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5363 const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5364 if( controls ) {
5365 num_valid_controls++;
5366 vehicle_position = elem;
5367 vehicle_controls = controls;
5368 }
5369 }
5370 }
5371 if( num_valid_controls < 1 ) {
5372 add_msg( _( "No vehicle controls found." ) );
5373 return;
5374 } else if( num_valid_controls > 1 ) {
5375 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5376 if( !vehicle_position ) {
5377 return;
5378 }
5379 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5380 if( vp ) {
5381 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5382 if( !vehicle_controls ) {
5383 add_msg( _( "The vehicle doesn't have controls there." ) );
5384 return;
5385 }
5386 } else {
5387 add_msg( _( "No vehicle there." ) );
5388 return;
5389 }
5390 }
5391 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5392 if( vehicle_controls ) {
5393 veh = &vehicle_controls->vehicle();
5394 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5395 return;
5396 }
5397 veh->use_controls( *vehicle_position );
5398 //May be folded up (destroyed), so need to re-get it
5399 veh = g->remoteveh();
5400 }
5401 }
5402 if( veh ) {
5403 // If we reached here, we gained control of a vehicle.
5404 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5405 for( const tripoint &target : veh->get_points() ) {
5406 u.clear_memorized_tile( m.getabs( target ) );
5407 }
5408 veh->is_following = false;
5409 veh->is_patrolling = false;
5410 veh->autopilot_on = false;
5411 veh->is_autodriving = false;
5412 }
5413}
cata::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1026
bool in_vehicle
Definition: character.h:1511
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:167
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2360
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8617
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1009
Simple wrapper to forward functions that may return a cata::optional to vpart_position.
Definition: player.h:91
bool engine_on
Definition: vehicle.h:1989
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6758
bool handle_potential_theft(player &p, bool check_only=false, bool prompt=true)
Definition: vehicle.cpp:4377
std::string name
Definition: vehicle.h:1849
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1031
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:251
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2545
bool autopilot_on
Definition: vehicle.h:1997
bool is_autodriving
Definition: vehicle.h:1982
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2461
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3076 of file game.cpp.

3077{
3079 if( !ui ) {
3080 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
3081 ui->on_redraw( []( const ui_adaptor & ) {
3082 g->draw();
3083 } );
3084 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
3085 // remove some space for the sidebar, this is the maximal space
3086 // (using standard font) that the terrain window can have
3087 const int sidebar_left = panel_manager::get_manager().get_width_left();
3088 const int sidebar_right = panel_manager::get_manager().get_width_right();
3089
3091 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
3094
3095 /**
3096 * In tiles mode w_terrain can have a different font (with a different
3097 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
3098 * might have a different dimension then the normal font used everywhere else.
3099 *
3100 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
3101 * be displayed in w_terrain (using it's specific tile dimension), not
3102 * including partially drawn squares at the right/bottom. You should
3103 * use it whenever you want to draw specific squares in that window or to
3104 * determine whether a specific square is draw on screen (or outside the screen
3105 * and needs scrolling).
3106 *
3107 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
3108 * w_terrain in the standard font dimension (the font that everything else uses).
3109 * You usually don't have to use it, expect for positioning of windows,
3110 * because the window positions use the standard font dimension.
3111 *
3112 * The code here calculates size available for w_terrain, caps it at
3113 * max_view_size (the maximal view range than any character can have at
3114 * any time).
3115 * It is stored in TERRAIN_WINDOW_*.
3116 */
3118
3119 // Position of the player in the terrain window, it is always in the center
3122
3124 point( sidebar_left, 0 ) );
3125
3126 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
3128
3129 // need to init in order to avoid crash. gets updated by the panel code.
3131
3132 ui.position_from_window( catacurses::stdscr );
3133 } );
3134 ui->mark_resize();
3135 }
3136 return ui;
3137}
catacurses::window w_pixel_minimap
Definition: game.h:1017
catacurses::window w_minimap_ptr
Definition: game.h:1054
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1100
catacurses::window w_minimap
Definition: game.h:1016
catacurses::window w_terrain_ptr
Definition: game.h:1053
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2170
int get_width_left()
Definition: panels.cpp:2178
Adaptor between UI code and the UI management system.
Definition: ui_manager.h:65
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 992 of file game.cpp.

993{
994 if( !get_option<bool>( "STATIC_NPC" ) ||
995 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
996 return; //Do not generate a starting npc.
997 }
998
999 //We don't want more than one starting npc per starting location
1000 const int radius = 1;
1001 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
1002 return; //There is already an NPC in this starting location
1003 }
1004
1005 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
1006 tmp->normalize();
1007 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
1008 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
1010 tmp->form_opinion( u );
1011 tmp->set_attitude( NPCATT_NULL );
1012 //This sets the NPC mission. This NPC remains in the starting location.
1013 tmp->mission = NPC_MISSION_SHELTER;
1014 tmp->chatbin.first_topic = "TALK_SHELTER";
1015 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
1016 tmp->set_fac( faction_id( "no_faction" ) );
1017 //One random starting NPC mission
1018 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
1019 tmp->getID() ) );
1020}
int get_levy() const
Definition: game.cpp:12008
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:12003
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:181
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:279
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4674 of file game.cpp.

4675{
4676 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4677 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4678 return nullptr;
4679 }
4680 // if we wanted to check for an NPC / player / avatar,
4681 // there is sometimes a monster AND an NPC/player there at the same time.
4682 // because the NPC/player etc may be riding that monster.
4683 // so only return the monster if we were actually looking for a monster.
4684 // otherwise, keep looking for the rider.
4685 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4686 // which is ok for the occasions where that happens.
4687 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4688 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4689 std::is_same<T, const Creature>::value ) ) {
4690 return dynamic_cast<T *>( mon_ptr.get() );
4691 }
4692 }
4693 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4694 if( p == u.pos() ) {
4695 return dynamic_cast<T *>( &u );
4696 }
4697 }
4698 for( auto &cur_npc : active_npc ) {
4699 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4700 return dynamic_cast<T *>( cur_npc.get() );
4701 }
4702 }
4703 return nullptr;
4704}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4707 of file game.cpp.

4708{
4709 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4710}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4753 of file game.cpp.

4754{
4755 if( id == u.getID() ) {
4756 // player is always alive, therefore no is-dead check
4757 return dynamic_cast<T *>( &u );
4758 }
4759 return find_npc( id );
4760}
character_id getID() const
Definition: character.cpp:477
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1981

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2524 of file game.cpp.

2525{
2526 gamemode->game_over();
2531 follower_ids.clear();
2533}
diary * get_avatar_diary()
Definition: avatar.cpp:368
void death_entry()
Definition: diary.cpp:672
stats_tracker & stats()
Definition: game.cpp:2884
void disp_NPC_epilogues()
Definition: game.cpp:2963
void display_faction_epilogues()
Definition: game.cpp:2980
void display_messages()
Definition: messages.cpp:801
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, diary::death_entry(), disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, avatar::get_avatar_diary(), get_kill_tracker(), show_scores_ui(), stats(), and u.

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11143 of file game.cpp.

11144{
11145 if( !critter.is_hallucination() ) {
11146 // hallucinations aren't stored, they come and go as they like,
11148 }
11149
11150 critter.on_unload();
11151 remove_zombie( critter );
11152 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11153 critter.set_hp( 0 );
11154}
void remove_zombie(const monster &critter)
Definition: game.cpp:4864
bool is_hallucination() const override
Definition: monster.cpp:2672
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:3004
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1655
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 8765 of file game.cpp.

8766{
8767 monster *const mon_ptr = critter_at<monster>( p );
8768 if( !mon_ptr ) {
8769 return false;
8770 }
8771 monster &critter = *mon_ptr;
8772 if( critter.friendly == 0 || critter.has_effect( effect_pet ) ||
8773 critter.has_flag( MF_RIDEABLE_MECH ) ||
8774 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
8775 // Can only disable / reprogram friendly monsters
8776 return false;
8777 }
8778 const auto mid = critter.type->id;
8779 const auto mon_item_id = critter.type->revert_to_itype;
8780 if( !mon_item_id.is_empty() &&
8781 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
8782
8783 u.moves -= 100;
8784 m.add_item_or_charges( p, critter.to_item() );
8785 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
8786 for( auto &ammodef : critter.ammo ) {
8787 if( ammodef.second > 0 ) {
8788 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
8789 }
8790 }
8791 }
8792 remove_zombie( critter );
8793 return true;
8794 }
8795 // Manhacks are special, they have their own menu here.
8796 if( mid == mon_manhack ) {
8797 int choice = UILIST_CANCEL;
8798 if( critter.has_effect( effect_docile ) ) {
8799 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
8800 } else {
8801 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
8802 }
8803 switch( choice ) {
8804 case 0:
8805 if( critter.has_effect( effect_docile ) ) {
8806 critter.remove_effect( effect_docile );
8807 if( one_in( 3 ) ) {
8808 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
8809 critter.name() );
8810 }
8811 } else {
8812 critter.add_effect( effect_docile, 1_turns, num_bp );
8813 if( one_in( 3 ) ) {
8814 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
8815 critter.name() );
8816 }
8817 }
8818 u.moves -= 100;
8819 return true;
8820 default:
8821 break;
8822 }
8823 }
8824 return false;
8825}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1136
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4194
bool has_flag(m_flag f) const override
Definition: monster.cpp:889
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2812
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1831
int friendly
Definition: monster.h:474
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:493
std::map< itype_id, int > ammo
Definition: monster.h:515
static const efftype_id effect_pet("pet")
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:364
constexpr point xy() const
Definition: point.h:220
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, effect_pet, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 2963 of file game.cpp.

2964{
2965 // TODO: This search needs to be expanded to all NPCs
2966 for( auto elem : follower_ids ) {
2968 if( !guy ) {
2969 continue;
2970 }
2971 const auto new_win = []() {
2973 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2974 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2975 };
2976 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
2977 }
2978}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 3014 of file game.cpp.

3015{
3016 const tripoint_abs_omt ppos = u.global_omt_location();
3017 const tripoint &lpos = u.pos();
3018 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
3019 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
3020
3022 ui_adaptor ui;
3023 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
3026 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
3027 ui.position_from_window( w );
3028 } );
3029 ui.mark_resize();
3030 ui.on_redraw( [&]( const ui_adaptor & ) {
3031 werase( w );
3032 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
3033 // NOLINTNEXTLINE(cata-use-named-point-constants)
3034 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
3035 size_t i;
3036 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
3037 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
3038 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
3039 apos.to_string() );
3040 }
3041 for( const monster &m : all_monsters() ) {
3042 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
3043 m.posx(), m.posy(), m.posz() );
3044 ++i;
3045 }
3046 wnoutrefresh( w );
3047 } );
3048
3049 input_context ctxt( "DISP_NPCS" );
3050 ctxt.register_action( "CONFIRM" );
3051 ctxt.register_action( "QUIT" );
3052 ctxt.register_action( "HELP_KEYBINDINGS" );
3053 bool stop = false;
3054 while( !stop ) {
3056 const std::string action = ctxt.handle_input();
3057 if( action == "CONFIRM" || action == "QUIT" ) {
3058 stop = true;
3059 }
3060 }
3061}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6336
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:386
std::string name(const tripoint &p)
Definition: map.cpp:1325
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:16

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 2980 of file game.cpp.

2981{
2982 for( const auto &elem : faction_manager_ptr->all() ) {
2983 if( elem.second.known_by_u ) {
2984 const std::vector<std::string> epilogue = elem.second.epilogue();
2985 if( !epilogue.empty() ) {
2986 const auto new_win = []() {
2988 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2989 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2990 };
2991 scrollable_text( new_win, elem.second.name,
2992 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
2993 []( const std::string & lhs, const std::string & rhs ) -> std::string {
2994 return lhs + "\n" + rhs;
2995 } ) );
2996 }
2997 }
2998 }
2999}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:1000

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11355 of file game.cpp.

11356{
11357 if( use_tiles ) {
11359 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11360 return;
11361 }
11362 uilist lighting_menu;
11363 std::vector<std::string> lighting_menu_strings{
11364 "Global lighting conditions"
11365 };
11366
11367 int count = 0;
11368 for( const auto &menu_str : lighting_menu_strings ) {
11369 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11370 }
11371
11372 lighting_menu.w_y_setup = 0;
11373 lighting_menu.query();
11374 if( ( lighting_menu.ret >= 0 ) &&
11375 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11376 g->displaying_lighting_condition = lighting_menu.ret;
11377 }
11378 }
11379}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:321
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11251
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11246 of file game.cpp.

11247{
11249}
cata::optional< action_id > displaying_overlays
Definition: game.h:945

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11381 of file game.cpp.

11382{
11383 if( use_tiles ) {
11385 }
11386}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:323

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11260 of file game.cpp.

11261{
11262 if( use_tiles ) {
11264 } else {
11265 int div;
11266 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11267 if( !got_value || div < 1 ) {
11268 add_msg( _( "Never mind." ) );
11269 return;
11270 }
11271 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11272 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11273 } );
11274 g->add_draw_callback( scent_cb );
11275
11278 }
11279}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:283
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1309
tripoint view_offset
Definition: player.h:589
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11281 of file game.cpp.

11282{
11283 if( use_tiles ) {
11285 }
11286}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:315

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11251 of file game.cpp.

11252{
11253 if( display_overlay_state( action ) ) {
11254 displaying_overlays.reset();
11255 } else {
11257 }
11258}
bool display_overlay_state(action_id)
Definition: game.cpp:11246

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11388 of file game.cpp.

11389{
11390 if( use_tiles ) {
11392 }
11393}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:325

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11288 of file game.cpp.

11289{
11290 if( use_tiles ) {
11292 }
11293}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:317

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11295 of file game.cpp.

11296{
11297 if( use_tiles ) {
11300 std::vector< tripoint > locations;
11301 uilist creature_menu;
11302 int num_creatures = 0;
11303 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11304 locations.emplace_back( g->u.pos() ); // add player first.
11305 for( const Creature &critter : g->all_creatures() ) {
11306 if( critter.is_player() ) {
11307 continue;
11308 }
11309 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11310 locations.emplace_back( critter.pos() );
11311 }
11312
11313 pointmenu_cb callback( locations );
11314 creature_menu.callback = &callback;
11315 creature_menu.w_y_setup = 0;
11316 creature_menu.query();
11317 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11318 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11320 }
11321 } else {
11323 }
11324 }
11325}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:319
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:4854
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1036
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1455 of file game.cpp.

1456{
1457 if( is_game_over() ) {
1458 return cleanup_at_end();
1459 }
1460 // Actual stuff
1461 if( new_game ) {
1462 new_game = false;
1463 } else {
1464 gamemode->per_turn();
1465 calendar::turn += 1_turns;
1466 }
1467
1468 // starting a new turn, clear out temperature cache
1470 weather.clear_temp_cache();
1471
1472 if( npcs_dirty ) {
1473 load_npcs();
1474 }
1475
1478 // If controlling a vehicle that is owned by someone else
1480 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1481 if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
1482 veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
1483 }
1484 }
1485 // If riding a horse - chance to spook
1486 if( u.is_mounted() ) {
1488 }
1489 if( calendar::once_every( 1_days ) ) {
1491 }
1492
1493 // Move hordes every 2.5 min
1496 // Hordes that reached the reality bubble need to spawn,
1497 // make them spawn in invisible areas only.
1498 m.spawn_monsters( false );
1499 }
1500
1502
1503 u.update_body();
1504
1505 // Auto-save if autosave is enabled
1506 if( get_option<bool>( "AUTOSAVE" ) &&
1507 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1508 !u.is_dead_state() ) {
1509 autosave();
1510 }
1511
1512 weather.update_weather();
1514
1518 // Process NPC sound events before they move or they hear themselves talking
1519 for( npc &guy : all_npcs() ) {
1520 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1522 }
1523 }
1524
1525 // Process sound events into sound markers for display to the player.
1527
1528 if( u.is_deaf() ) {
1530 }
1531
1532 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1533 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1534 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1535 cleanup_dead();
1537 // Process any new sounds the player caused during their turn.
1538 for( npc &guy : all_npcs() ) {
1539 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1541 }
1542 }
1545 wait_popup.reset();
1547 }
1548
1549 if( queue_screenshot ) {
1553 queue_screenshot = false;
1554 }
1555
1556 if( handle_action() ) {
1558 u.action_taken();
1559 }
1560
1561 if( is_game_over() ) {
1562 return cleanup_at_end();
1563 }
1564
1565 if( uquit == QUIT_WATCH ) {
1566 break;
1567 }
1568 if( u.activity ) {
1570 }
1571 }
1572 // Reset displayed sound markers now that the turn is over.
1573 // We only want this to happen if the player had a chance to examine the sounds.
1575 }
1576 }
1577
1578 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1579 // Still have a view offset, but might not be driving anymore,
1580 // or the option has been deactivated,
1581 // might also happen when someone dives from a moving car.
1582 // or when using the handbrake.
1583 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1584 calc_driving_offset( veh );
1585 }
1586
1587 // No-scent debug mutation has to be processed here or else it takes time to start working
1588 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1589 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1592 }
1593 scent.update( u.pos(), m );
1594
1595 // We need floor cache before checking falling 'n stuff
1597
1600 m.vehmove();
1601 m.process_fields();
1602 m.process_items();
1605
1606 // Apply sounds from previous turn to monster and NPC AI.
1608 // Update vision caches for monsters. If this turns out to be expensive,
1609 // consider a stripped down cache just for monsters.
1610 m.build_map_cache( get_levz(), true );
1611 monmove();
1612 if( calendar::once_every( 5_minutes ) ) {
1614 }
1615 if( calendar::once_every( 10_seconds ) ) {
1616 for( const tripoint &elem : m.get_furn_field_locations() ) {
1617 const auto &furn = m.furn( elem ).obj();
1618 for( const emit_id &e : furn.emissions ) {
1619 m.emit_field( elem, e );
1620 }
1621 }
1622 }
1625 u.process_turn();
1626
1628 cleanup_dead();
1629
1630 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1633 }
1634
1635 if( get_levz() >= 0 && !u.is_underwater() ) {
1636 handle_weather_effects( weather.weather_id );
1637 }
1638
1639 const bool player_is_sleeping = u.has_effect( effect_sleep );
1640 bool wait_redraw = false;
1641 std::string wait_message;
1642 time_duration wait_refresh_rate;
1643 if( player_is_sleeping ) {
1644 wait_redraw = true;
1645 wait_message = _( "Wait till you wake up…" );
1646 wait_refresh_rate = 30_minutes;
1647 if( calendar::once_every( 1_hours ) ) {
1649 }
1650 } else if( u.has_destination() ) {
1651 wait_redraw = true;
1652 wait_message = _( "Travelling…" );
1653 wait_refresh_rate = 15_turns;
1654 } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1655 wait_redraw = true;
1656 wait_message = *progress;
1657 if( u.activity.id() == ACT_AUTODRIVE ) {
1658 wait_refresh_rate = 1_turns;
1659 } else {
1660 wait_refresh_rate = 5_minutes;
1661 }
1662 }
1663 if( wait_redraw ) {
1665 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1666 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1668 }
1669
1670 // Avoid redrawing the main UI every time due to invalidation
1672 wait_popup = std::make_unique<static_popup>();
1673 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1677 }
1678 } else {
1679 // Nothing to wait for now
1680 wait_popup.reset();
1682 }
1683
1685 u.update_body_wetness( get_weather().get_precise() );
1686 u.apply_wetness_morale( weather.temperature );
1687
1688 if( calendar::once_every( 1_minutes ) ) {
1689 u.update_morale();
1690 }
1691
1692 if( calendar::once_every( 9_turns ) ) {
1694 }
1695
1696 if( !u.is_deaf() ) {
1698 }
1703
1704 // reset player noise
1705 u.volume = 0;
1706
1707 return false;
1708}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:9005
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:877
bool check_mount_is_spooked()
Definition: character.cpp:1102
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5183
bool is_mounted() const
Definition: character.cpp:1143
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8764
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9132
bool is_deaf() const
Definition: character.cpp:4486
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4665
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1887
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1804
virtual bool is_underwater() const
Definition: creature.cpp:174
int get_levz() const
Definition: game.cpp:12013
void overmap_npc_move()
Definition: game.cpp:4353
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12123
void monmove()
Definition: game.cpp:4228
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1773
void add_artifact_dreams()
Definition: game.cpp:11957
int moves_since_last_save
Definition: game.h:1066
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7288
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1353
bool cleanup_at_end()
Definition: game.cpp:1049
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1102
bool queue_screenshot
Definition: game.h:1045
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11446
void process_activity()
Definition: game.cpp:1762
void update_stair_monsters()
Definition: game.cpp:10934
void process_voluntary_act_interrupt()
Definition: game.cpp:1722
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:917
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1073
void cleanup_dead()
Definition: game.cpp:4193
bool is_game_over()
Definition: game.cpp:2477
void perhaps_add_random_npc()
Definition: game.cpp:11181
void mon_info_update()
Definition: game.cpp:3992
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:8062
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2274
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1928
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7759
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7718
void vehmove()
Definition: map.cpp:414
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1563
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1348
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8228
void process_items()
Definition: map.cpp:4580
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
cata::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
bool is_dead_state() const override
Returns true if the player should be dead.
Definition: player.cpp:777
int volume
Definition: player.h:592
int scent
Definition: player.h:601
void update_body_wetness(const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
Definition: player.cpp:1564
void process_turn() override
Resets movement points and applies other non-idempotent changes.
Definition: player.cpp:277
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:150
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1261
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1614
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1609
void do_danger_music()
Definition: sounds.cpp:1613
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1615
void do_fatigue()
Definition: sounds.cpp:1634
void remove_hearing_loss()
Definition: sounds.cpp:1610
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3251 of file game.cpp.

3252{
3253 if( test_mode ) {
3254 return;
3255 }
3256
3257 //temporary fix for updating visibility for minimap
3258 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3261
3262 werase( w_terrain );
3263 draw_ter();
3264 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3265 shared_ptr_fast<draw_callback_t> cb = it->lock();
3266 if( cb ) {
3267 ( *cb )();
3268 ++it;
3269 } else {
3270 it = draw_callbacks.erase( it );
3271 }
3272 }
3274
3275 draw_panels( true );
3276}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:1012
void draw_panels(bool force_draw=false)
Definition: game.cpp:3278
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3392
void update_visibility_cache(int zlev)
Definition: map.cpp:5608
int z
Definition: point.h:152

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 963 of file animation.cpp.

964{
965}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 518 of file animation.cpp.

520{
521 draw_bullet_curses( m, t, bullet, &trajectory[i] );
522}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:459
std::vector< tripoint > trajectory
Definition: ranged.h:32

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3374 of file game.cpp.

3375{
3376 draw_critter_internal( w_terrain, critter, center, false, m, u );
3377}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3341

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3379 of file game.cpp.

3380{
3381 draw_critter_internal( w_terrain, critter, center, true, m, u );
3382}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 724 of file animation.cpp.

725{
726 const tripoint rp = relative_view_pos( *this, p );
727 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
728}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:127
void mvwputch_inv(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 919 of file animation.cpp.

920{
921}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 880 of file animation.cpp.

881{
882}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 893 of file animation.cpp.

894{
895}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 737 of file animation.cpp.

738{
739 // Do nothing
740}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 581 of file animation.cpp.

582{
583 draw_hit_mon_curses( p, m, u, dead );
584}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:552

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 626 of file animation.cpp.

627{
628 draw_hit_player_curses( *this, p, dam );
629}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:589

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 933 of file animation.cpp.

935{
936}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 710 of file animation.cpp.

711{
712 draw_line_curses( *this, points );
713}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:690

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 677 of file animation.cpp.

679{
680 if( !u.sees( p ) ) {
681 return;
682 }
683
684 draw_line_curses( *this, center, points, noreveal );
685}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5823 of file game.cpp.

5824{
5825 if( !liveview.is_enabled() ) {
5826#if defined( TILES )
5827 if( is_draw_tiles_mode() ) {
5828 draw_cursor( lp );
5829 return;
5830 }
5831#endif
5832 const tripoint view_center = u.pos() + u.view_offset;
5833 visibility_type visibility = VIS_HIDDEN;
5834 const bool inbounds = m.inbounds( lp );
5835 if( inbounds ) {
5836 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5837 }
5838 if( visibility == VIS_CLEAR ) {
5839 const Creature *const creature = critter_at( lp, true );
5840 if( creature != nullptr && u.sees( *creature ) ) {
5841 creature->draw( w_terrain, view_center, true );
5842 } else {
5843 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5844 }
5845 } else {
5846 std::string visibility_indicator;
5847 nc_color visibility_indicator_color = c_white;
5848 switch( visibility ) {
5849 case VIS_CLEAR:
5850 // Already handled by the outer if statement
5851 break;
5852 case VIS_BOOMER:
5853 case VIS_BOOMER_DARK:
5854 visibility_indicator = '#';
5855 visibility_indicator_color = c_pink;
5856 break;
5857 case VIS_DARK:
5858 visibility_indicator = '#';
5859 visibility_indicator_color = c_dark_gray;
5860 break;
5861 case VIS_LIT:
5862 visibility_indicator = '#';
5863 visibility_indicator_color = c_light_gray;
5864 break;
5865 case VIS_HIDDEN:
5866 visibility_indicator = 'x';
5867 visibility_indicator_color = c_white;
5868 break;
5869 }
5870
5871 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
5872 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
5873 }
5874 }
5875}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:724
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4674
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7769
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5662
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:729
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5840
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2029
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:180

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3452 of file game.cpp.

3453{
3454
3455 // Draw the box
3456 werase( w_minimap );
3458
3459 const tripoint_abs_omt curs = u.global_omt_location();
3460 const point_abs_omt curs2( curs.xy() );
3462 bool drew_mission = targ == overmap::invalid_tripoint;
3463
3464 for( int i = -2; i <= 2; i++ ) {
3465 for( int j = -2; j <= 2; j++ ) {
3466 const point_abs_omt om( curs2 + point( i, j ) );
3467 nc_color ter_color;
3468 tripoint_abs_omt omp( om, get_levz() );
3469 std::string ter_sym;
3470 const bool seen = overmap_buffer.seen( omp );
3471 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3472 if( overmap_buffer.has_note( omp ) ) {
3473
3474 const std::string &note_text = overmap_buffer.note( omp );
3475
3476 ter_color = c_yellow;
3477 ter_sym = "N";
3478
3479 int symbolIndex = note_text.find( ':' );
3480 int colorIndex = note_text.find( ';' );
3481
3482 bool symbolFirst = symbolIndex < colorIndex;
3483
3484 if( colorIndex > -1 && symbolIndex > -1 ) {
3485 if( symbolFirst ) {
3486 if( colorIndex > 4 ) {
3487 colorIndex = -1;
3488 }
3489 if( symbolIndex > 1 ) {
3490 symbolIndex = -1;
3491 colorIndex = -1;
3492 }
3493 } else {
3494 if( symbolIndex > 4 ) {
3495 symbolIndex = -1;
3496 }
3497 if( colorIndex > 2 ) {
3498 colorIndex = -1;
3499 }
3500 }
3501 } else if( colorIndex > 2 ) {
3502 colorIndex = -1;
3503 } else if( symbolIndex > 1 ) {
3504 symbolIndex = -1;
3505 }
3506
3507 if( symbolIndex > -1 ) {
3508 int symbolStart = 0;
3509 if( colorIndex > -1 && !symbolFirst ) {
3510 symbolStart = colorIndex + 1;
3511 }
3512 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3513 }
3514
3515 if( colorIndex > -1 ) {
3516
3517 int colorStart = 0;
3518
3519 if( symbolIndex > -1 && symbolFirst ) {
3520 colorStart = symbolIndex + 1;
3521 }
3522
3523 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3524
3525 if( sym.length() == 2 ) {
3526 if( sym == "br" ) {
3527 ter_color = c_brown;
3528 } else if( sym == "lg" ) {
3529 ter_color = c_light_gray;
3530 } else if( sym == "dg" ) {
3531 ter_color = c_dark_gray;
3532 }
3533 } else {
3534 char colorID = sym.c_str()[0];
3535 if( colorID == 'r' ) {
3536 ter_color = c_light_red;
3537 } else if( colorID == 'R' ) {
3538 ter_color = c_red;
3539 } else if( colorID == 'g' ) {
3540 ter_color = c_light_green;
3541 } else if( colorID == 'G' ) {
3542 ter_color = c_green;
3543 } else if( colorID == 'b' ) {
3544 ter_color = c_light_blue;
3545 } else if( colorID == 'B' ) {
3546 ter_color = c_blue;
3547 } else if( colorID == 'W' ) {
3548 ter_color = c_white;
3549 } else if( colorID == 'C' ) {
3550 ter_color = c_cyan;
3551 } else if( colorID == 'c' ) {
3552 ter_color = c_light_cyan;
3553 } else if( colorID == 'P' ) {
3554 ter_color = c_pink;
3555 } else if( colorID == 'm' ) {
3556 ter_color = c_magenta;
3557 }
3558 }
3559 }
3560 } else if( !seen ) {
3561 ter_sym = " ";
3562 ter_color = c_black;
3563 } else if( vehicle_here ) {
3564 ter_color = c_cyan;
3565 ter_sym = "c";
3566 } else {
3567 const oter_id &cur_ter = overmap_buffer.ter( omp );
3568 ter_sym = cur_ter->get_symbol();
3569 if( overmap_buffer.is_explored( omp ) ) {
3570 ter_color = c_dark_gray;
3571 } else {
3572 ter_color = cur_ter->get_color();
3573 }
3574 }
3575 if( !drew_mission && targ.xy() == omp.xy() ) {
3576 // If there is a mission target, and it's not on the same
3577 // overmap terrain as the player character, mark it.
3578 // TODO: Inform player if the mission is above or below
3579 drew_mission = true;
3580 if( i != 0 || j != 0 ) {
3581 ter_color = red_background( ter_color );
3582 }
3583 }
3584 if( i == 0 && j == 0 ) {
3585 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3586 } else {
3587 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3588 }
3589 }
3590 }
3591
3592 // Print arrow to mission if we have one!
3593 if( !drew_mission ) {
3594 double slope = curs2.x() != targ.x() ?
3595 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3596
3597 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3598 if( targ.y() > curs2.y() ) {
3599 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3600 } else {
3601 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3602 }
3603 } else {
3604 int arrowx = -1;
3605 int arrowy = -1;
3606 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3607 arrowy = targ.y() > curs2.y() ? 6 : 0;
3608 arrowx =
3609 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3610 if( arrowx < 0 ) {
3611 arrowx = 0;
3612 }
3613 if( arrowx > 6 ) {
3614 arrowx = 6;
3615 }
3616 } else {
3617 arrowx = targ.x() > curs2.x() ? 6 : 0;
3618 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3619 if( arrowy < 0 ) {
3620 arrowy = 0;
3621 }
3622 if( arrowy > 6 ) {
3623 arrowy = 6;
3624 }
3625 }
3626 char glyph = '*';
3627 if( targ.z() > u.posz() ) {
3628 glyph = '^';
3629 } else if( targ.z() < u.posz() ) {
3630 glyph = 'v';
3631 }
3632
3633 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3634 }
3635 }
3636
3637 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3638 for( int i = -3; i <= 3; i++ ) {
3639 for( int j = -3; j <= 3; j++ ) {
3640 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3641 continue; // only do hordes on the border, skip inner map
3642 }
3643 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3645 if( overmap_buffer.seen( omp )
3646 && g->u.overmap_los( omp, sight_points ) ) {
3647 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3648 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3649 }
3650 }
3651 }
3652 }
3653
3655}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:205
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:209
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:217

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 977 of file animation.cpp.

979{
980}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3278 of file game.cpp.

3279{
3280 static int previous_turn = -1;
3281 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3282 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3283 auto &mgr = panel_manager::get_manager();
3284 int y = 0;
3285 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3286 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3287 int log_height = 0;
3288 for( const window_panel &panel : mgr.get_current_layout() ) {
3289 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3290 log_height += panel.get_height() + spacer;
3291 }
3292 }
3293 log_height = std::max( TERMY - log_height, 3 );
3294 for( const window_panel &panel : mgr.get_current_layout() ) {
3295 if( panel.render() ) {
3296 // height clamped to window height.
3297 int h = std::min( panel.get_height(), TERMY - y );
3298 if( h == -2 ) {
3299 h = log_height;
3300 }
3301 h += spacer;
3302 if( panel.toggle && panel.render() && h > 0 ) {
3303 if( panel.always_draw || draw_this_turn ) {
3304 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3305 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3306 }
3307 if( show_panel_adm ) {
3308 const std::string panel_name = _( panel.get_name() );
3309 const int panel_name_width = utf8_width( panel_name );
3310 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3311 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3312 werase( label );
3313 mvwprintz( label, point_zero, c_light_red, panel_name );
3315 label = catacurses::newwin( h, 1,
3316 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3317 werase( label );
3318 if( h == 1 ) {
3320 } else {
3322 for( int i = 1; i < h - 1; i++ ) {
3324 }
3325 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3326 }
3328 }
3329 y += h;
3330 }
3331 }
3332 }
3333 previous_turn = current_turn;
3334}
bool show_panel_adm
Definition: game.h:1040
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:578

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3336 of file game.cpp.

3337{
3338 w_pixel_minimap = w;
3339}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 854 of file animation.cpp.

855{
856}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 805 of file animation.cpp.

806{
807 draw_sct_curses( *this );
808}
void draw_sct_curses(const game &g)
Definition: animation.cpp:772

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3392 of file game.cpp.

3393{
3395 draw_sounds );
3396}
bool is_looking
Definition: game.h:250

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3398 of file game.cpp.

3399{
3401
3402 m.draw( w_terrain, center );
3403
3404 if( draw_sounds ) {
3406 }
3407
3408 for( Creature &critter : all_creatures() ) {
3409 draw_critter( critter, center );
3410 }
3411
3412 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3413 // Draw auto-move preview trail
3414 const tripoint &final_destination = destination_preview.back();
3415 tripoint line_center = u.pos() + u.view_offset;
3416 draw_line( final_destination, line_center, destination_preview, true );
3417 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3418 POSY - u.posy() ), c_white, 'X' );
3419 }
3420
3421 if( u.controlling_vehicle && !looking ) {
3422 draw_veh_dir_indicator( false );
3423 draw_veh_dir_indicator( true );
3424 }
3425 // Place the cursor over the player as is expected by screen readers.
3426 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3427}
int posx() const override
Definition: character.h:779
int posy() const override
Definition: character.h:782
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3374
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:12113
std::vector< tripoint > destination_preview
Definition: game.h:1092
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3444
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:677
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5712
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:3064
void wmove(const window &win, const point &p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 867 of file animation.cpp.

868{
869}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 7136 of file game.cpp.

7137{
7138 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7139}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:7106

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 906 of file animation.cpp.

907{
908}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3444 of file game.cpp.

3445{
3446 if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3447 auto col = next ? c_white : c_dark_gray;
3448 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3449 }
3450}
cata::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3429

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
const point mount 
)

Definition at line 949 of file animation.cpp.

951{
952}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 764 of file animation.cpp.

765{
767}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:745

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 840 of file animation.cpp.

841{
842 draw_zones_curses( w_terrain, start, end, offset );
843}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:813

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8179 of file game.cpp.

8180{
8182}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2505
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8184 of file game.cpp.

8185{
8186 if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8187 u.drop( game_menus::inv::multidrop( u ), *pnt );
8188 }
8189}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 38 of file dump.cpp.

40{
41 try {
42 loading_ui ui( false );
44 load_packs( _( "Loading content packs" ), { mod_management::get_default_core_content_pack() }, ui );
46 } catch( const std::exception &err ) {
47 std::cerr << "Error loading data from json: " << err.what() << std::endl;
48 return false;
49 }
50
51 std::vector<std::string> header;
52 std::vector<std::vector<std::string>> rows;
53
54 int scol = 0; // sorting column
55
56 std::map<std::string, standard_npc> test_npcs;
57 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
58 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
59 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
60 4, 8, 8, 8, 10 /* PER 10 */ );
61 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
62 4, 10, 8, 8, 8 /* STAT 10 */ );
63 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
64 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
65 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
66 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
67
68 std::map<std::string, item> test_items;
69 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
70 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
71 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
72 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
73 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
74
75 if( what == "AMMO" ) {
76 header = {
77 "Name", "Ammo", "Volume", "Weight", "Stack",
78 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
79 };
80 auto dump = [&rows]( const item & obj ) {
81 std::vector<std::string> r;
82 r.push_back( obj.tname( 1, false ) );
83 r.push_back( obj.ammo_type().str() );
84 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
85 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
86 r.push_back( std::to_string( obj.type->stack_size ) );
87 r.push_back( std::to_string( obj.type->ammo->range ) );
88 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
89 r.push_back( std::to_string( obj.type->ammo->recoil ) );
90 damage_instance damage = obj.type->ammo->damage;
91 r.push_back( std::to_string( damage.total_damage() ) );
92 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
93 rows.push_back( r );
94 };
95 for( const itype *e : item_controller->all() ) {
96 if( e->ammo ) {
97 dump( item( e, calendar::turn, item::solitary_tag {} ) );
98 }
99 }
100
101 } else if( what == "ARMOR" ) {
102 header = {
103 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
104 };
105 auto dump = [&rows]( const item & obj ) {
106 std::vector<std::string> r;
107 r.push_back( obj.tname( 1, false ) );
108 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
109 r.push_back( std::to_string( obj.get_warmth() ) );
110 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
111 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
112 r.push_back( std::to_string( obj.get_coverage() ) );
113 r.push_back( std::to_string( obj.bash_resist() ) );
114 r.push_back( std::to_string( obj.cut_resist() ) );
115 r.push_back( std::to_string( obj.bullet_resist() ) );
116 r.push_back( std::to_string( obj.acid_resist() ) );
117 r.push_back( std::to_string( obj.fire_resist() ) );
118 rows.push_back( r );
119 };
120
121 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
122
123 for( const itype *e : item_controller->all() ) {
124 if( e->armor ) {
125 item obj( e );
126 if( bp == num_bp || obj.covers( bp ) ) {
127 if( obj.has_flag( flag_VARSIZE ) ) {
128 obj.set_flag( "FIT" );
129 }
130 dump( obj );
131 }
132 }
133 }
134
135 } else if( what == "EDIBLE" ) {
136 header = {
137 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
138 };
139 for( const auto &v : vitamin::all() ) {
140 header.push_back( v.second.name() );
141 }
142 auto dump = [&rows]( const item & obj ) {
143 std::vector<std::string> r;
144 r.push_back( obj.tname( 1, false ) );
145 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
146 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
147 r.push_back( std::to_string( obj.type->stack_size ) );
148 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
149 r.push_back( std::to_string( obj.get_comestible()->quench ) );
150 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
151 auto vits = obj.get_comestible()->default_nutrition.vitamins;
152 for( const auto &v : vitamin::all() ) {
153 r.push_back( std::to_string( vits[ v.first ] ) );
154 }
155 rows.push_back( r );
156 };
157
158 for( const itype *e : item_controller->all() ) {
160
161 if( food.is_food() && g->u.can_eat( food ).success() ) {
162 dump( food );
163 }
164 }
165
166 } else if( what == "GUN" ) {
167 header = {
168 "Name", "Ammo", "Volume", "Weight", "Capacity",
169 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
170 "Aim time", "Effective range", "Snapshot range", "Max range"
171 };
172
173 std::set<std::string> locations;
174 for( const itype *e : item_controller->all() ) {
175 if( e->gun ) {
176 std::transform( e->gun->valid_mod_locations.begin(),
177 e->gun->valid_mod_locations.end(),
178 std::inserter( locations, locations.begin() ),
179 []( const std::pair<gunmod_location, int> &q ) {
180 return q.first.name();
181 } );
182 }
183 }
184 for( const auto &e : locations ) {
185 header.push_back( e );
186 }
187
188 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
189 std::vector<std::string> r;
190 r.push_back( obj.tname( 1, false ) );
191 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
192 obj.ammo_types().end(), []( const ammotype & at ) {
193 return at.str();
195 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
196 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
197 r.push_back( std::to_string( obj.ammo_capacity() ) );
198 r.push_back( std::to_string( obj.gun_range() ) );
199 r.push_back( std::to_string( obj.gun_dispersion() ) );
200 r.push_back( std::to_string( obj.gun_recoil() ) );
201 damage_instance damage = obj.gun_damage();
202 r.push_back( std::to_string( damage.total_damage() ) );
203 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
204
205 r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
206
207 for( const auto &e : locations ) {
208 const auto &vml = obj.type->gun->valid_mod_locations;
209 const auto iter = vml.find( e );
210 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
211 }
212 rows.push_back( r );
213 };
214 for( const itype *e : item_controller->all() ) {
215 if( e->gun ) {
216 item gun( e );
217 if( !gun.magazine_integral() ) {
218 gun.put_in( item( gun.magazine_default() ) );
219 }
220 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
221
222 dump( test_npcs[ "S1" ], gun );
223
224 if( gun.type->gun->barrel_length > 0_ml ) {
225 gun.put_in( item( "barrel_small" ) );
226 dump( test_npcs[ "S1" ], gun );
227 }
228 }
229 }
230
231 } else if( what == "RECIPE" ) {
232
233 // optionally filter recipes to include only those using specified skills
234 recipe_subset dict;
235 for( const auto &r : recipe_dict ) {
236 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
237 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
238 return true;
239 }
240 const auto iter = r.second.required_skills.find( skill_id( s ) );
241 return iter != r.second.required_skills.end() && iter->second > 0;
242 } ) ) {
243 dict.include( &r.second );
244 }
245 }
246
247 // only consider skills that are required by at least one recipe
248 std::vector<Skill> sk;
249 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
250 std::back_inserter( sk ), [&dict]( const Skill & s ) {
251 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
252 return r->skill_used == s.ident() ||
253 r->required_skills.find( s.ident() ) != r->required_skills.end();
254 } );
255 } );
256
257 header = { "Result" };
258
259 for( const auto &e : sk ) {
260 header.push_back( e.ident().str() );
261 }
262
263 for( const recipe *e : dict ) {
264 std::vector<std::string> r;
265 r.push_back( e->result_name() );
266 for( const auto &s : sk ) {
267 if( e->skill_used == s.ident() ) {
268 r.push_back( std::to_string( e->difficulty ) );
269 } else {
270 auto iter = e->required_skills.find( s.ident() );
271 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
272 }
273 }
274 rows.push_back( r );
275 }
276
277 } else if( what == "VEHICLE" ) {
278 header = {
279 "Name", "Weight (empty)", "Weight (fueled)",
280 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
281 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
282 };
283 auto dump = [&rows]( const vproto_id & obj ) {
284 vehicle veh_empty( obj, 0, 0 );
285 vehicle veh_fueled( obj, 100, 0 );
286
287 std::vector<std::string> r;
288 r.push_back( veh_empty.name );
289 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
290 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
291 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
293 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
294 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
295 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
296 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
297 r.push_back( std::to_string( static_cast<int>( 50 *
298 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
299 rows.push_back( r );
300 };
301 for( auto &e : vehicle_prototype::get_all() ) {
302 dump( e );
303 }
304
305 } else if( what == "VPART" ) {
306 header = {
307 "Name", "Location", "Weight", "Size"
308 };
309 auto dump = [&rows]( const vpart_info & obj ) {
310 std::vector<std::string> r;
311 r.push_back( obj.name() );
312 r.push_back( obj.location );
313 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
314 r.push_back( std::to_string( w ) );
315 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
316 rows.push_back( r );
317 };
318 for( const auto &e : vpart_info::all() ) {
319 dump( e.second );
320 }
321
322 } else {
323 std::cerr << "unknown argument: " << what << std::endl;
324 return false;
325 }
326
327 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
328 return e.empty();
329 } ), rows.end() );
330
331 if( scol >= 0 ) {
332 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
333 const std::vector<std::string> &rhs ) {
334 return localized_compare( lhs[ scol ], rhs[ scol ] );
335 } );
336 }
337
338 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
339
340 switch( mode ) {
341 case dump_mode::TSV:
342 rows.insert( rows.begin(), header );
343 for( const auto &r : rows ) {
344 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
345 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
346 std::cout << r.back() << "\n";
347 }
348 break;
349
350 case dump_mode::HTML:
351 std::cout << "<table>";
352
353 std::cout << "<thead>";
354 std::cout << "<tr>";
355 for( const auto &col : header ) {
356 std::cout << "<th>" << col << "</th>";
357 }
358 std::cout << "</tr>";
359 std::cout << "</thead>";
360
361 std::cout << "<tdata>";
362 for( const auto &r : rows ) {
363 std::cout << "<tr>";
364 for( const auto &col : r ) {
365 std::cout << "<td>" << col << "</td>";
366 }
367 std::cout << "</tr>";
368 }
369 std::cout << "</tdata>";
370
371 std::cout << "</table>";
372 break;
373 }
374
375 return true;
376}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
bool load_packs(const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
Load content packs.
Definition: game.cpp:2769
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4865
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:990
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:590
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1394
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:694
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1636
mod_id get_default_core_content_pack()
Get id of default core content pack.
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:680
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:197
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), mod_management::get_default_core_content_pack(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 2879 of file game.cpp.

2880{
2881 return *event_bus_ptr;
2882}
pimpl< event_bus > event_bus_ptr
Definition: game.h:979

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
const point cp = point_zero 
)

open vehicle interaction screen

Definition at line 5133 of file game.cpp.

5134{
5135 if( veh.magic ) {
5136 add_msg( m_info, _( "This is your %s" ), veh.name );
5137 return;
5138 }
5139 auto act = veh_interact::run( veh, c );
5140 if( act ) {
5141 u.moves = 0;
5143 }
5144}
static player_activity run(vehicle &veh, const point &p)
bool magic
Definition: vehicle.h:1866
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5524 of file game.cpp.

5525{
5526 // if we are driving a vehicle, examine the
5527 // current tile without asking.
5528 const optional_vpart_position vp = m.veh_at( u.pos() );
5529 if( vp && vp->vehicle().player_in_control( u ) ) {
5530 examine( u.pos() );
5531 return;
5532 }
5533
5534 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5535 _( "There is nothing that can be examined nearby." ),
5536 ACTION_EXAMINE, false );
5537 if( !examp_ ) {
5538 return;
5539 }
5540 u.manual_examine = true;
5541 examine( *examp_ );
5542 u.manual_examine = false;
5543}
cata::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1042
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:105
void examine()
Definition: game.cpp:5524
bool manual_examine
Definition: player.h:605

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5612 of file game.cpp.

5613{
5614 if( disable_robot( examp ) ) {
5615 return;
5616 }
5617
5618 Creature *c = critter_at( examp );
5619 if( c != nullptr ) {
5620 monster *mon = dynamic_cast<monster *>( c );
5621 if( mon != nullptr ) {
5622 add_msg( _( "There is a %s." ), mon->get_name() );
5623 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5624 if( monexamine::pet_menu( *mon ) ) {
5625 return;
5626 }
5627 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5628 if( monexamine::mech_hack( *mon ) ) {
5629 return;
5630 }
5631 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5632 if( monexamine::pay_bot( *mon ) ) {
5633 return;
5634 }
5635 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5636 if( monexamine::mfriend_menu( *mon ) ) {
5637 return;
5638 }
5639 }
5640 } else if( u.is_mounted() ) {
5641 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5642 }
5643 npc *np = dynamic_cast<npc *>( c );
5644 if( np != nullptr && !u.is_mounted() ) {
5645 if( npc_menu( *np ) ) {
5646 return;
5647 }
5648 } else if( np != nullptr && u.is_mounted() ) {
5649 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5650 }
5651 }
5652
5653 const optional_vpart_position vp = m.veh_at( examp );
5654 if( vp && u.is_mounted() ) {
5655 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5656 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5657 } else {
5658 vp->vehicle().interact_with( examp, vp->part_index() );
5659 return;
5660 }
5661 } else if( vp && !u.is_mounted() ) {
5662 vp->vehicle().interact_with( examp, vp->part_index() );
5663 return;
5664 }
5665
5666 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5667 use_computer( examp );
5668 return;
5669 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5670 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5671 }
5672 const furn_t &xfurn_t = m.furn( examp ).obj();
5673 const ter_t &xter_t = m.ter( examp ).obj();
5674
5675 const tripoint player_pos = u.pos();
5676
5677 if( m.has_furn( examp ) && !u.is_mounted() ) {
5678 xfurn_t.examine( u, examp );
5679 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5680 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5681 } else {
5682 if( !u.is_mounted() ) {
5683 xter_t.examine( u, examp );
5684 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5685 xter_t.examine( u, examp );
5686 } else {
5687 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5688 }
5689 }
5690
5691 // Did the player get moved? Bail out if so; our examp probably
5692 // isn't valid anymore.
5693 if( player_pos != u.pos() ) {
5694 return;
5695 }
5696
5697 bool none = true;
5698 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5699 none = false;
5700 }
5701
5702 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5703 iexamine::trap( u, examp );
5704 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5705 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5706 }
5707
5708 // In case of teleport trap or somesuch
5709 if( player_pos != u.pos() ) {
5710 return;
5711 }
5712
5713 // Feedback for fire lasting time, this can be judged while mounted
5714 const std::string fire_fuel = get_fire_fuel_string( examp );
5715 if( !fire_fuel.empty() ) {
5716 add_msg( fire_fuel );
5717 }
5718
5719 if( m.has_flag( "SEALED", examp ) ) {
5720 if( none ) {
5721 if( m.has_flag( "UNSTABLE", examp ) ) {
5722 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5723 } else {
5724 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5725 }
5726 }
5727 } else {
5728 //examp has no traps, is a container and doesn't have a special examination function
5729 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5730 m.has_flag( "CONTAINER", examp ) && none ) {
5731 add_msg( _( "It is empty." ) );
5732 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5733 xfurn_t.examine == &iexamine::fireplace ) ||
5734 xfurn_t.examine == &iexamine::workbench ) {
5735 return;
5736 } else {
5738 if( !u.is_mounted() ) {
5739 pickup::pick_up( examp, 0 );
5740 }
5741 }
5742 }
5743}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1556
@ A_FRIENDLY
Definition: creature.h:171
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4642
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:8765
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5415
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1343
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5137
ter_id ter(const tripoint &p) const
Definition: map.cpp:1498
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1040
std::string get_name() const override
Definition: monster.cpp:488
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5545
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2888
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6105
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:249
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3787
bool pet_menu(monster &z)
Definition: monexamine.cpp:67
bool mech_hack(monster &z)
Definition: monexamine.cpp:425
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:497
bool pay_bot(monster &z)
Definition: monexamine.cpp:457
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:571
iexamine_function examine
Definition: mapdata.h:398
Definition: mapdata.h:457
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 51 of file descriptions.cpp.

52{
54 const int top = 3;
55 int width = 0;
56 catacurses::window w_head;
57 catacurses::window w_main;
58 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
59 const int left = 0;
60 const int right = TERMX;
61 const int bottom = TERMY;
62 width = right - left;
63 const int height = bottom - top;
64 w_head = catacurses::newwin( top, TERMX, point_zero );
65 w_main = catacurses::newwin( height, width, point( left, top ) );
66 ui.position( point_zero, point( TERMX, TERMY ) );
67 } );
68 ui.mark_resize();
69
70 // Default to critter (if any), furniture (if any), then terrain.
72 if( seen_critter( *this, p ) != nullptr ) {
74 } else if( get_map().has_furn( p ) ) {
76 }
77
78 std::string action;
79 input_context ctxt( "EXTENDED_DESCRIPTION" );
80 ctxt.register_action( "CREATURE" );
81 ctxt.register_action( "FURNITURE" );
82 ctxt.register_action( "TERRAIN" );
83 ctxt.register_action( "CONFIRM" );
84 ctxt.register_action( "QUIT" );
85 ctxt.register_action( "HELP_KEYBINDINGS" );
86
87 ui.on_redraw( [&]( const ui_adaptor & ) {
88 werase( w_head );
90 _( "[%s] describe creatures, [%s] describe furniture, "
91 "[%s] describe terrain, [%s] close." ),
92 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
93 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
94
95 // Set up line drawings
96 for( int i = 0; i < TERMX; i++ ) {
97 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
98 }
99
100 wnoutrefresh( w_head );
101
102 std::string desc;
103 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
104 switch( cur_target ) {
106 const Creature *critter = seen_critter( *this, p );
107 if( critter != nullptr ) {
108 desc = critter->extended_description();
109 } else {
110 desc = _( "You do not see any creature here." );
111 }
112 }
113 break;
115 if( !u.sees( p ) || !m.has_furn( p ) ) {
116 desc = _( "You do not see any furniture here." );
117 } else {
118 const furn_id fid = m.furn( p );
119 if( display_mod_source ) {
120 const std::string mod_src = enumerate_as_string( fid->src.begin(),
121 fid->src.end(), []( const std::pair<furn_str_id, mod_id> &source ) {
122 return string_format( "'%s'", source.second->name() );
124 desc = string_format( _( "Origin: %s\n%s" ), mod_src, fid->extended_description() );
125 } else {
126 desc = fid.obj().extended_description();
127 }
128 }
129 break;
131 if( !u.sees( p ) ) {
132 desc = _( "You can't see the terrain here." );
133 } else {
134 const ter_id tid = m.ter( p );
135 if( display_mod_source ) {
136 const std::string mod_src = enumerate_as_string( tid->src.begin(),
137 tid->src.end(), []( const std::pair<ter_str_id, mod_id> &source ) {
138 return string_format( "'%s'", source.second->name() );
140 desc = string_format( _( "Origin: %s\n%s" ), mod_src, tid->extended_description() );
141 } else {
142 desc = tid.obj().extended_description();
143 }
144 }
145 break;
146 }
147
148 std::string signage = m.get_signage( p );
149 if( !signage.empty() ) {
150 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
151 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
152 signage );
153 }
154
155 werase( w_main );
156 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
157 wnoutrefresh( w_main );
158 } );
159
160 do {
162 action = ctxt.handle_input();
163 if( action == "CREATURE" ) {
164 cur_target = description_target::creature;
165 } else if( action == "FURNITURE" ) {
167 } else if( action == "TERRAIN" ) {
168 cur_target = description_target::terrain;
169 }
170 } while( action != "CONFIRM" && action != "QUIT" );
171}
bool display_mod_source
Display mod source for items, furniture, terrain and monsters.
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:146
std::string get_signage(const tripoint &p) const
Definition: map.cpp:4000
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, const point &begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::vector< std::pair< furn_str_id, mod_id > > src
Definition: mapdata.h:494
std::string extended_description() const
std::vector< std::pair< ter_str_id, mod_id > > src
Definition: mapdata.h:459

References _, action, arrow, c_light_gray, c_white, creature, display_mod_source, enumerate_as_string(), map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), ter_t::src, furn_t::src, string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 7064 of file game.cpp.

7065{
7066 std::map<std::string, map_item_stack> temp_items;
7067 std::vector<map_item_stack> ret;
7068 std::vector<std::string> item_order;
7069
7070 if( u.is_blind() ) {
7071 return ret;
7072 }
7073
7074 int range = fov_3d ? ( fov_3d_z_range * 2 ) + 1 : 1;
7075 int center_z = u.pos().z;
7076
7077 for( int i = 1; i <= range; i++ ) {
7078 int z = i % 2 ? center_z - i / 2 : center_z + i / 2;
7079 for( auto &points_p_it : closest_points_first( {u.pos().xy(), z}, iRadius ) ) {
7080 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
7081 u.sees( points_p_it ) &&
7082 m.sees_some_items( points_p_it, u ) ) {
7083
7084 for( auto &elem : m.i_at( points_p_it ) ) {
7085 const std::string name = elem.tname();
7086 const tripoint relative_pos = points_p_it - u.pos();
7087
7088 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
7089 item_order.push_back( name );
7090 temp_items[name] = map_item_stack( &elem, relative_pos );
7091 } else {
7092 temp_items[name].add_at_pos( &elem, relative_pos );
7093 }
7094 }
7095 }
7096 }
7097 }
7098
7099 for( auto &elem : item_order ) {
7100 ret.push_back( temp_items[elem] );
7101 }
7102
7103 return ret;
7104}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool fov_3d
3D FoV enabled/disabled.
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6342
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), fov_3d, fov_3d_z_range, map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), u, and tripoint::z.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1981 of file game.cpp.

1982{
1983 return overmap_buffer.find_npc( id ).get();
1984}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10554 of file game.cpp.

10556{
10557 const int omtilesz = SEEX * 2;
10558 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10559 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10560 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10561
10562 // Try to find the stairs.
10564 int best = INT_MAX;
10565 const int movez = z_after - get_levz();
10566 const bool going_down_1 = movez == -1;
10567 const bool going_up_1 = movez == 1;
10568 // If there are stairs on the same x and y as we currently are, use those
10569 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10570 stairs.emplace( u.pos() + tripoint_below );
10571 }
10572 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10573 stairs.emplace( u.pos() + tripoint_above );
10574 }
10575 // We did not find stairs directly above or below, so search the map for them
10576 if( !stairs.has_value() ) {
10577 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10578 if( rl_dist( u.pos(), dest ) <= best &&
10579 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10580 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10581 mp.ter( dest ) == t_manhole_cover ) ) ||
10582 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10583 stairs.emplace( dest );
10584 best = rl_dist( u.pos(), dest );
10585 }
10586 }
10587 }
10588
10589 if( stairs.has_value() ) {
10590 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10591 npc *guy = dynamic_cast<npc *>( blocking_creature );
10592 monster *mon = dynamic_cast<monster *>( blocking_creature );
10593 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10594 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10595 std::string cr_name = blocking_creature->get_name();
10596 std::string msg;
10597 if( guy ) {
10598 //~ %s is the name of hostile NPC
10599 msg = string_format( _( "%s is in the way!" ), cr_name );
10600 } else {
10601 //~ %s is some monster
10602 msg = string_format( _( "There's a %s in the way!" ), cr_name );
10603 }
10604
10605 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
10606 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
10607 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
10608 add_msg( msg );
10609 return cata::nullopt;
10610 }
10611 }
10612 return stairs;
10613 }
10614
10615 // No stairs found! Try to make some
10616 rope_ladder = false;
10617 stairs.emplace( u.pos() );
10618 stairs->z = z_after;
10619 // Check the destination area for lava.
10620 if( mp.ter( *stairs ) == t_lava ) {
10621 if( movez < 0 &&
10622 !query_yn(
10623 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
10624 return cata::nullopt;
10625 } else if( movez > 0 &&
10626 !query_yn(
10627 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
10628 return cata::nullopt;
10629 }
10630
10631 return stairs;
10632 }
10633
10634 if( movez > 0 ) {
10635 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
10636 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
10637 return cata::nullopt;
10638 }
10639 }
10640 // Manhole covers need this to work
10641 // Maybe require manhole cover here and fail otherwise?
10642 return stairs;
10643 }
10644
10645 if( mp.impassable( *stairs ) ) {
10646 popup( _( "Halfway down, the way down becomes blocked off." ) );
10647 return cata::nullopt;
10648 }
10649
10650 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
10651 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
10652 rope_ladder = true;
10653 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
10654 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
10655 } else {
10656 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
10657 }
10658 } else {
10659 return cata::nullopt;
10660 }
10661 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
10662 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
10663 if( u.has_trait( trait_VINES2 ) ) {
10664 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
10665 rope_ladder = true;
10666 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
10667 u.mod_pain( 5 );
10668 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
10669 u.mod_stored_nutr( 10 );
10670 u.mod_thirst( 10 );
10671 } else {
10672 add_msg( _( "You gingerly descend using your vines." ) );
10673 }
10674 } else {
10675 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
10676 rope_ladder = true;
10677 u.mod_stored_nutr( 10 );
10678 u.mod_thirst( 10 );
10679 }
10680 } else {
10681 return cata::nullopt;
10682 }
10683 } else if( u.has_amount( itype_grapnel, 1 ) ) {
10684 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
10685 rope_ladder = true;
10687 } else {
10688 return cata::nullopt;
10689 }
10690 } else if( u.has_amount( itype_rope_30, 1 ) ) {
10691 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
10692 rope_ladder = true;
10694 } else {
10695 return cata::nullopt;
10696 }
10697 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
10698 return cata::nullopt;
10699 }
10700
10701 return stairs;
10702}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8407
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9631
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4414
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4304
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3356
T & emplace(Args &&... args)
Definition: optional.h:146
constexpr bool has_value() const noexcept
Definition: optional.h:123
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8278
bool impassable(const tripoint &p) const
Definition: map.cpp:1795
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8607
bool is_enemy() const
Definition: npc.cpp:2043
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: player.cpp:945
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static cata::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:10090
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:720
ter_id t_lava
Definition: mapdata.cpp:695
ter_id t_elevator
Definition: mapdata.cpp:723
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr nullopt_t nullopt
Definition: optional.h:22
static constexpr tripoint tripoint_below
Definition: point.h:295
static constexpr tripoint tripoint_above
Definition: point.h:294

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false,
bool  suppress_map_update = false 
)

Flings the input creature in the given direction.

Definition at line 9892 of file game.cpp.

9894{
9895 if( c == nullptr ) {
9896 debugmsg( "game::fling_creature invoked on null target" );
9897 return;
9898 }
9899
9900 if( c->is_dead_state() ) {
9901 // Flinging a corpse causes problems, don't enable without testing
9902 return;
9903 }
9904
9905 if( c->is_hallucination() ) {
9906 // Don't fling hallucinations
9907 return;
9908 }
9909
9910 bool thru = true;
9911 const bool is_u = ( c == &u );
9912 // Don't animate critters getting bashed if animations are off
9913 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
9914
9915 player *p = dynamic_cast<player *>( c );
9916
9917 tileray tdir( dir );
9918 int range = flvel / 10;
9919 tripoint pt = c->pos();
9920 tripoint prev_point = pt;
9921 bool force_next = false;
9922 tripoint next_forced;
9923 while( range > 0 ) {
9924 c->underwater = false;
9925 // TODO: Check whenever it is actually in the viewport
9926 // or maybe even just redraw the changed tiles
9927 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
9928 if( force_next ) {
9929 pt = next_forced;
9930 force_next = false;
9931 } else {
9932 tdir.advance();
9933 pt.x = c->posx() + tdir.dx();
9934 pt.y = c->posy() + tdir.dy();
9935 }
9936 float force = 0;
9937
9938 if( m.obstructed_by_vehicle_rotation( prev_point, pt ) ) {
9939 //We process the intervening tile on this iteration and then the current tile on the next
9940 next_forced = pt;
9941 force_next = true;
9942 if( one_in( 2 ) ) {
9943 pt.x = prev_point.x;
9944 } else {
9945 pt.y = prev_point.y;
9946 }
9947 }
9948
9949
9950 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
9951 monster &critter = *mon_ptr;
9952 // Approximate critter's "stopping power" with its max hp
9953 force = std::min<float>( 1.5f * critter.type->hp, flvel );
9954 const int damage = rng( force, force * 2.0f ) / 6;
9955 c->impact( damage, pt );
9956 // Multiply zed damage by 6 because no body parts
9957 const int zed_damage = std::max( 0,
9958 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
9959 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
9960 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
9961 critter.check_dead_state();
9962 if( !critter.is_dead() ) {
9963 thru = false;
9964 }
9965 } else if( m.impassable( pt ) ) {
9966 if( !m.veh_at( pt ).obstacle_at_part() ) {
9967 force = std::min<float>( m.bash_strength( pt ), flvel );
9968 } else {
9969 // No good way of limiting force here
9970 // Keep it 1 less than maximum to make the impact hurt
9971 // but to keep the target flying after it
9972 force = flvel - 1;
9973 }
9974 const int damage = rng( force, force * 2.0f ) / 9;
9975 c->impact( damage, pt );
9976 if( m.is_bashable( pt ) ) {
9977 // Only go through if we successfully make the tile passable
9978 m.bash( pt, flvel );
9979 thru = m.passable( pt );
9980 } else {
9981 thru = false;
9982 }
9983 }
9984
9985 // If the critter dies during flinging, moving it around causes debugmsgs
9986 if( c->is_dead_state() ) {
9987 return;
9988 }
9989
9990 flvel -= force;
9991 if( thru ) {
9992 if( p != nullptr ) {
9993 if( p->in_vehicle ) {
9994 m.unboard_vehicle( p->pos() );
9995 }
9996 // If we're flinging the player around, make sure the map stays centered on them.
9997 if( is_u && !suppress_map_update ) {
9998 update_map( pt.x, pt.y );
9999 } else {
10000 p->setpos( pt );
10001 }
10002 } else if( !critter_at( pt ) ) {
10003 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
10004 // Just don't setpos if it happens - next iteration will do so
10005 // or the monster will stop a tile before the unpassable one
10006 c->setpos( pt );
10007 }
10008 } else {
10009 // Don't zero flvel - count this as slamming both the obstacle and the ground
10010 // although at lower velocity
10011 break;
10012 }
10013 //Vehicle wall tiles don't count for range
10014 if( !force_next ) {
10015 range--;
10016 }
10017 prev_point = pt;
10018 if( animate && ( seen || u.sees( *c ) ) ) {
10023 }
10024 }
10025
10026 // Fall down to the ground - always on the last reached tile
10027 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
10028 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
10029 // Didn't smash into a wall or a floor so only take the fall damage
10030 if( thru && trap_under_creature == tr_ledge ) {
10031 m.creature_on_trap( *c, false );
10032 } else {
10033 // Fall on ground
10034 int force = rng( flvel, flvel * 2 ) / 9;
10035 if( controlled ) {
10036 force = std::max( force / 2 - 5, 0 );
10037 }
10038 if( force > 0 ) {
10039 int dmg = c->impact( force, c->pos() );
10040 // TODO: Make landing damage the floor
10041 m.bash( c->pos(), dmg / 4, false, false, false );
10042 }
10043 // Always apply traps to creature i.e. bear traps, tele traps etc.
10044 m.creature_on_trap( *c, false );
10045 }
10046 } else {
10047 c->underwater = true;
10048 if( is_u ) {
10049 if( controlled ) {
10050 add_msg( _( "You dive into water." ) );
10051 } else {
10052 add_msg( m_warning, _( "You fall into water." ) );
10053 }
10054 }
10055 }
10056}
void setpos(const tripoint &p) override
Definition: character.h:797
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1839
point update_map(player &p)
Definition: game.cpp:10781
void pump_events()
Resize & refresh if necessary, process all pending window events, and ignore keypresses.
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2460
bool obstructed_by_vehicle_rotation(const tripoint &from, const tripoint &to) const
Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent.
Definition: map.cpp:6495
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3527
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1081
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2425
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8484
bool passable(const tripoint &p) const
Definition: map.cpp:1800
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1879
bool is_dead() const
Definition: monster.cpp:2777
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1660
cata::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2493
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Redraw all invalidated windows without invalidating the top window.
Definition: ui_manager.cpp:394
int hp
Definition: mtype.h:270
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:151
int x
Definition: point.h:150

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, inp_mngr, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::obstructed_by_vehicle_rotation(), one_in(), map::passable(), Character::pos(), input_manager::pump_events(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5146 of file game.cpp.

5147{
5148 const auto valid_location = [&]( const tripoint & p ) {
5149 return g->is_empty( p );
5150 };
5151 const auto get_random_point = [&]() -> tripoint {
5152 if( auto pos = random_point( m.points_in_radius( p, 2 ), valid_location ) )
5153 {
5154 return p * 2 - ( *pos );
5155 } else
5156 {
5157 return p;
5158 }
5159 };
5160
5161 const std::string &door_name = door_type.obj().name();
5162 const tripoint kbp = get_random_point();
5163
5164 // can't pushback any creatures/items anywhere, that means the door can't close.
5165 const bool cannot_push = kbp == p;
5166 const bool can_see = u.sees( p );
5167
5168 player *npc_or_player = critter_at<player>( p, false );
5169 if( npc_or_player != nullptr ) {
5170 if( bash_dmg <= 0 ) {
5171 return false;
5172 }
5173 if( npc_or_player->is_npc() && can_see ) {
5174 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5175 } else if( npc_or_player->is_player() ) {
5176 add_msg( m_bad, _( "The %s hits you." ), door_name );
5177 }
5178 if( npc_or_player->activity ) {
5179 npc_or_player->cancel_activity();
5180 }
5181 // TODO: make the npc angry?
5182 npc_or_player->hitall( bash_dmg, 0, nullptr );
5183 if( cannot_push ) {
5184 return false;
5185 }
5186 // TODO implement who was closing the door and replace nullptr
5187 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1, nullptr );
5188 // TODO: perhaps damage/destroy the gate
5189 // if the npc was really big?
5190 }
5191 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5192 monster &critter = *mon_ptr;
5193 if( bash_dmg <= 0 ) {
5194 return false;
5195 }
5196 if( can_see ) {
5197 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5198 }
5199 if( critter.type->size <= MS_SMALL ) {
5200 critter.die_in_explosion( nullptr );
5201 } else {
5202 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5203 critter.check_dead_state();
5204 }
5205 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5206 // big critters simply prevent the gate from closing
5207 // TODO: perhaps damage/destroy the gate
5208 // if the critter was really big?
5209 return false;
5210 }
5211 if( !critter.is_dead() ) {
5212 // Still alive? Move the critter away so the door can close
5213 if( cannot_push ) {
5214 return false;
5215 }
5216 // TODO implement who was closing the door and replace nullptr
5217 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1, nullptr );
5218 if( critter_at( p ) ) {
5219 return false;
5220 }
5221 }
5222 }
5223 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5224 if( bash_dmg <= 0 ) {
5225 return false;
5226 }
5227 vp->vehicle().damage( vp->part_index(), bash_dmg );
5228 if( m.veh_at( p ) ) {
5229 // Check again in case all parts at the door tile
5230 // have been destroyed, if there is still a vehicle
5231 // there, the door can not be closed
5232 return false;
5233 }
5234 }
5235 if( bash_dmg < 0 && !m.i_at( p ).empty() ) {
5236 return false;
5237 }
5238 if( bash_dmg == 0 ) {
5239 for( auto &elem : m.i_at( p ) ) {
5240 if( elem.made_of( LIQUID ) ) {
5241 // Liquids are OK, will be destroyed later
5242 continue;
5243 } else if( elem.volume() < 250_ml ) {
5244 // Dito for small items, will be moved away
5245 continue;
5246 }
5247 // Everything else prevents the door from closing
5248 return false;
5249 }
5250 }
5251
5252 m.ter_set( p, door_type );
5253 if( m.has_flag( "NOITEM", p ) ) {
5254 map_stack items = m.i_at( p );
5255 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5256 if( it->made_of( LIQUID ) ) {
5257 it = items.erase( it );
5258 continue;
5259 }
5260 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5261 if( can_see ) {
5262 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5263 } else {
5264 add_msg( m_warning, _( "Something shatters!" ) );
5265 }
5266 it = items.erase( it );
5267 continue;
5268 }
5269 if( cannot_push ) {
5270 return false;
5271 }
5272 m.add_item_or_charges( kbp, *it );
5273 it = items.erase( it );
5274 }
5275 }
5276 return true;
5277}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8684
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult, Creature *source)
Definition: game.cpp:4402
iterator erase(const_iterator it) override
Definition: map.cpp:152
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1639
void die_in_explosion(Creature *source)
Definition: monster.cpp:1674
bool is_npc() const override
Definition: player.h:123
bool is_player() const override
Definition: player.h:106
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
cata::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:511
m_size size
Definition: mtype.h:262

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::empty(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, and map::veh_at().

◆ gametype()

special_game_id game::gametype ( ) const

Definition at line 646 of file game.cpp.

647{
648 return gamemode ? gamemode->id() : SGAME_NULL;
649}
@ SGAME_NULL
Definition: enums.h:93

References gamemode, and SGAME_NULL.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12128 of file game.cpp.

12129{
12130 for( Creature &critter : all_creatures() ) {
12131 if( pred( critter ) ) {
12132 return &critter;
12133 }
12134 }
12135 return nullptr;
12136}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 12038 of file game.cpp.

12040{
12041 std::vector<Creature *> result;
12042 for( Creature &critter : all_creatures() ) {
12043 if( pred( critter ) ) {
12044 result.push_back( &critter );
12045 }
12046 }
12047 return result;
12048}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 12018 of file game.cpp.

12019{
12020 // The player is located in the middle submap of the map.
12022 const tripoint pos_om = sm_to_om_copy( sm );
12023 // TODO: fix point types
12024 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
12025}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8288
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(const point &p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8849 of file game.cpp.

8850{
8851 std::vector<std::string> harmful_stuff;
8852 const auto fields_here = m.field_at( u.pos() );
8853 for( const auto &e : m.field_at( dest_loc ) ) {
8854 // warn before moving into a dangerous field except when already standing within a similar field
8855 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
8856 harmful_stuff.push_back( e.second.name() );
8857 }
8858 }
8859
8860 if( !u.is_blind() ) {
8861 const trap &tr = m.tr_at( dest_loc );
8862 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
8863 true ) );
8864 // HACK: Hack for now, later ledge should stop being a trap
8865 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
8866 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
8867 if( !boardable ) {
8868 harmful_stuff.emplace_back( tr.name() );
8869 }
8870 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
8871 harmful_stuff.emplace_back( tr.name() );
8872 }
8873
8874 static const std::set< body_part > sharp_bps = {
8877 };
8878
8879 const auto sharp_bp_check = [this]( body_part bp ) {
8880 return u.immune_to( bp, { DT_CUT, 10 } );
8881 };
8882
8883 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
8884 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
8885 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
8886 harmful_stuff.emplace_back( m.name( dest_loc ) );
8887 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
8888 m.veh_at( dest_loc ) ) &&
8889 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
8890 harmful_stuff.emplace_back( m.name( dest_loc ) );
8891 }
8892
8893 }
8894
8895 return harmful_stuff;
8896}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:248
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6971
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:196
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5299
bool has_zlevels() const
Definition: map.h:1684
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2481
bool immune_to(body_part bp, damage_unit dam) const
Check if a given body part is immune to a given damage type.
Definition: player.cpp:928
@ DT_CUT
Definition: damage.h:25
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3761 of file game.cpp.

3762{
3763 // We're going to get the contiguous fishable terrain starting at
3764 // the provided fishing location (e.g. where a line was cast or a fish
3765 // trap was set), and then check whether or not fishable monsters are
3766 // actually in those locations. This will help us ensure that we're
3767 // getting our fish from the location that we're ACTUALLY fishing,
3768 // rather than just somewhere in the vicinity.
3769
3770 std::unordered_set<tripoint> visited;
3771
3772 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3773 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3774
3775 const inclusive_cuboid<tripoint> fishing_boundaries(
3776 fishing_boundary_min, fishing_boundary_max );
3777
3778 const auto get_fishable_terrain = [&]( tripoint starting_point,
3779 std::unordered_set<tripoint> &fishable_terrain ) {
3780 std::queue<tripoint> to_check;
3781 to_check.push( starting_point );
3782 while( !to_check.empty() ) {
3783 const tripoint current_point = to_check.front();
3784 to_check.pop();
3785
3786 // We've been here before, so bail.
3787 if( visited.find( current_point ) != visited.end() ) {
3788 continue;
3789 }
3790
3791 // This point is out of bounds, so bail.
3792 if( !fishing_boundaries.contains( current_point ) ) {
3793 continue;
3794 }
3795
3796 // Mark this point as visited.
3797 visited.emplace( current_point );
3798
3799 if( m.has_flag( "FISHABLE", current_point ) ) {
3800 fishable_terrain.emplace( current_point );
3801 to_check.push( current_point + point_south );
3802 to_check.push( current_point + point_north );
3803 to_check.push( current_point + point_east );
3804 to_check.push( current_point + point_west );
3805 }
3806 }
3807 return;
3808 };
3809
3810 // Starting at the provided location, get our fishable terrain
3811 // and populate a set with those locations which we'll then use
3812 // to determine if any fishable monsters are in those locations.
3813 std::unordered_set<tripoint> fishable_points;
3814 get_fishable_terrain( fish_pos, fishable_points );
3815
3816 return fishable_points;
3817}
static constexpr point point_west
Definition: point.h:282
static constexpr point point_south
Definition: point.h:280
static constexpr point point_north
Definition: point.h:276
static constexpr point point_east
Definition: point.h:278

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 3819 of file game.cpp.

3821{
3822 std::vector<monster *> unique_fish;
3823 for( monster &critter : all_monsters() ) {
3824 // If it is fishable...
3825 if( critter.has_flag( MF_FISHABLE ) ) {
3826 const tripoint critter_pos = critter.pos();
3827 // ...and it is in a fishable location.
3828 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
3829 unique_fish.push_back( &critter );
3830 }
3831 }
3832 }
3833
3834 return unique_fish;
3835}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 2078 of file game.cpp.

2079{
2080 return follower_ids;
2081}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 987 of file game.cpp.

988{
989 return *kill_tracker_ptr;
990}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 12003 of file game.cpp.

12004{
12005 return m.get_abs_sub().x;
12006}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 12008 of file game.cpp.

12009{
12010 return m.get_abs_sub().y;
12011}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7240 of file game.cpp.

7241{
7242 return moves_since_last_save;
7243}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 12050 of file game.cpp.

12051{
12052 std::vector<npc *> result;
12053 for( npc &guy : all_npcs() ) {
12054 if( pred( guy ) ) {
12055 result.push_back( &guy );
12056 }
12057 }
12058 return result;
12059}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12138 of file game.cpp.

12139{
12140 return get_world_base_save_path() + "/" + base64_encode( u.name );
12141}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12143

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 240 of file handle_action.cpp.

241{
242 input_context ctxt;
243 if( uquit == QUIT_WATCH ) {
244 ctxt = input_context( "DEFAULTMODE" );
245 ctxt.set_iso( true );
246 // The list of allowed actions in death-cam mode in game::handle_action
247 // *INDENT-OFF*
248 for( const action_id id : {
261 } ) {
262 ctxt.register_action( action_ident( id ) );
263 }
264 // *INDENT-ON*
265 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
266 } else {
268 }
269
271
272 user_turn current_turn;
273
274
275 // Checking early if we will need to handle animations
276 // If we do not need to handle animations that will not change as long as the user has not selected an action
277 // and we can handle it like we are not animating.
278 weather_printable wPrint;
279 bool animate_weather = false;
280 bool animate_sct = false;
281 bool do_animations = [&]() {
282 if( get_option<bool>( "ANIMATIONS" ) ) {
283 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
284
285 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
286 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
287
288#if defined(TILES)
289 // Always animate, minimap and terrain may have animations to run
290 return true;
291#else
292 // Otherwise we need to see if we actually should animate.
293 // Minimap and Terrain never animate in !TILES
294 return animate_weather || animate_sct || uquit == QUIT_WATCH;
295#endif
296 }
297 return false;
298 }
299 ();
300
301 if( do_animations ) {
302 ctxt.set_timeout( 125 );
303
305 make_shared_fast<game::draw_callback_t>( [&]() {
306 if( animate_weather ) {
307 draw_weather( wPrint );
308 }
309 if( animate_sct ) {
310 draw_sct();
311 }
312 } );
313 add_draw_callback( animation_cb );
314 invalidate_main_ui_adaptor(); // We want to redraw at least once.
315
316 do {
317 if( animate_weather ) {
319 generate_weather_anim_frame( get_weather().weather_id, wPrint );
320 }
321 // don't bother calculating SCT if we won't show it
322 if( animate_sct ) {
324
326
327 //Check for creatures on all drawing positions and offset if necessary
328 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
329 const direction oCurDir = iter->getDirecton();
330 const int width = utf8_width( iter->getText() );
331 for( int i = 0; i < width; ++i ) {
332 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
333 const Creature *critter = critter_at( tmp, true );
334
335 if( critter != nullptr && u.sees( *critter ) ) {
336 i = -1;
337 int iPos = iter->getStep() + iter->getStepOffset();
338 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
339 if( iter2->getDirecton() == oCurDir &&
340 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
341 if( iter2->getType() == "hp" ) {
342 iter2->advanceStepOffset();
343 }
344
345 iter2->advanceStepOffset();
346 iPos = iter2->getStep() + iter2->getStepOffset();
347 }
348 }
349 }
350 }
351 }
352
353 // Stop animation when done
354 animate_sct = !SCT.vSCT.empty();
355 }
356 // We don't cache these checks as their result may change after 1st redraw
358 // TODO: we redraw *everything* just to animate a couple blinking dots
359 // on the minimap or a few tiles.
360 // This is far from ideal, and can probably be done much cheaper
361 // (update only part of the screen? draw static parts into a texture?)
363 }
364
365 std::unique_ptr<static_popup> deathcam_msg_popup;
366 if( uquit == QUIT_WATCH ) {
367 deathcam_msg_popup = std::make_unique<static_popup>();
368 deathcam_msg_popup
369 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
370 .on_top( true );
371 }
372
374 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
375 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
376 ctxt.reset_timeout();
377 } else {
380 SCT.vSCT.clear();
381
382 ctxt.set_timeout( 125 );
383 while( handle_mouseview( ctxt, action ) ) {
384 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
385 break;
386 }
387 }
388 ctxt.reset_timeout();
389 }
390
391 return ctxt;
392}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:68
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:22
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:77
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:89
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:93
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:259
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:83
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:75
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:87
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:85
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:119
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:81
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:91
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:79
bool terrain_requires_animation()
Definition: animation.cpp:1144
bool minimap_requires_animation()
Definition: animation.cpp:1135
void draw_sct()
Definition: animation.cpp:805
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:764
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3174
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2109
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1458
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:756
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:676
void set_iso(bool mode=true)
Definition: input.cpp:1429
void reset_timeout()
Definition: input.cpp:1463
std::vector< cSCT > vSCT
Definition: output.h:959
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2209
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1890 of file game.cpp.

1891{
1892 return seed;
1893}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7245 of file game.cpp.

7246{
7247 return user_action_counter;
7248}

References user_action_counter.

◆ get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3429 of file game.cpp.

3430{
3431 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3432 return cata::nullopt;
3433 }
3434 const optional_vpart_position vp = m.veh_at( u.pos() );
3435 if( !vp ) {
3436 return cata::nullopt;
3437 }
3438 vehicle *const veh = &vp->vehicle();
3439 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3440 float r = 10.0;
3441 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3442}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12143 of file game.cpp.

12144{
12145 if( world_generator->active_world == nullptr ) {
12146 return PATH_INFO::savedir();
12147 }
12148 return world_generator->active_world->folder_path();
12149}
std::string savedir()
Definition: path_info.cpp:254

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7231 of file game.cpp.

7232{
7233#if defined(TILES)
7234 return tileset_zoom;
7235#else
7236 return DEFAULT_TILESET_ZOOM;
7237#endif
7238}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 9652 of file game.cpp.

9653{
9654 // Furniture: pull, push, or standing still and nudging object around.
9655 // Can push furniture out of reach.
9656 tripoint fpos = u.pos() + u.grab_point;
9657 // supposed position of grabbed furniture
9658 if( !m.has_furn( fpos ) ) {
9659 // Where did it go? We're grabbing thin air so reset.
9660 add_msg( m_info, _( "No furniture at grabbed point." ) );
9661 u.grab( OBJECT_NONE );
9662 return false;
9663 }
9664
9665 const bool pushing_furniture = dp == u.grab_point;
9666 const bool pulling_furniture = dp == -u.grab_point;
9667 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
9668
9669 tripoint fdest = fpos + dp; // intended destination of furniture.
9670 // Check floor: floorless tiles don't need to be flat and have no traps
9671 const bool has_floor = m.has_floor( fdest );
9672 // Unfortunately, game::is_empty fails for tiles we're standing on,
9673 // which will forbid pulling, so:
9674 const bool canmove = (
9675 m.passable( fdest ) &&
9676 critter_at<npc>( fdest ) == nullptr &&
9677 critter_at<monster>( fdest ) == nullptr &&
9678 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
9679 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
9680 !m.has_furn( fdest ) &&
9681 !m.veh_at( fdest ) &&
9682 ( !has_floor || m.tr_at( fdest ).is_null() )
9683 );
9684
9685 const furn_t furntype = m.furn( fpos ).obj();
9686 const int src_items = m.i_at( fpos ).size();
9687 const int dst_items = m.i_at( fdest ).size();
9688
9689 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
9690 [&]( item & liquid_item ) {
9691 return liquid_item.made_of( LIQUID );
9692 } );
9693
9694 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
9695 !m.has_flag( "SWIMMABLE", fdest ) &&
9696 !m.has_flag( "DESTROY_ITEM", fdest );
9697
9698 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
9699 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
9700 m.furn( fpos ).obj().has_flag( "SEALED" );
9701
9702 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
9703 time_duration fire_age = m.get_field_age( fpos, fd_fire );
9704
9705 int str_req = furntype.move_str_req;
9706 // Factor in weight of items contained in the furniture.
9707 units::mass furniture_contents_weight = 0_gram;
9708 for( auto &contained_item : m.i_at( fpos ) ) {
9709 furniture_contents_weight += contained_item.weight();
9710 }
9711 str_req += furniture_contents_weight / 4_kilogram;
9712 if( !canmove ) {
9713 // TODO: What is something?
9714 add_msg( _( "The %s collides with something." ), furntype.name() );
9715 u.moves -= 50;
9716 return true;
9717 ///\EFFECT_STR determines ability to drag furniture
9718 } else if( str_req > u.get_str() &&
9719 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
9720 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
9721 furntype.name() );
9722 u.moves -= 100;
9723 u.mod_pain( 1 ); // Hurt ourselves.
9724 return true; // furniture and or obstacle wins.
9725 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
9726 add_msg( _( "There's stuff in the way." ) );
9727 u.moves -= 50;
9728 return true;
9729 }
9730
9731 u.moves -= str_req * 10;
9732 // Additional penalty if we can't comfortably move it.
9733 if( str_req > u.get_str() ) {
9734 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
9735 if( move_penalty <= 1000 ) {
9736 if( u.get_str() >= str_req - 3 ) {
9737 u.moves -= std::max( 3000, move_penalty * 10 );
9738 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
9739 if( one_in( 3 ) ) {
9740 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
9741 return true;
9742 }
9743 } else {
9744 u.moves -= 100;
9745 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
9746 return true;
9747 }
9748 }
9749 u.moves -= move_penalty;
9750 if( move_penalty > 500 ) {
9751 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
9752 furntype.name() );
9753 } else if( move_penalty > 200 ) {
9754 if( one_in( 3 ) ) { // Nag only occasionally.
9755 add_msg( _( "It takes some time to move the heavy %s." ),
9756 furntype.name() );
9757 }
9758 }
9759 }
9761 _( "a scraping noise." ), true, "misc", "scraping" );
9762
9764 ( tripoint_abs_ms( m.getabs( fpos ) ) );
9765
9766 // Actually move the furniture.
9767 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
9768 m.furn_set( fpos, f_null );
9769
9770 if( fire_intensity == 1 && !pulling_furniture ) {
9771 m.remove_field( fpos, fd_fire );
9772 m.set_field_intensity( fdest, fd_fire, fire_intensity );
9773 m.set_field_age( fdest, fd_fire, fire_age );
9774 }
9775
9776 // Is there is only liquids on the ground, remove them after moving furniture.
9777 if( dst_items > 0 && only_liquid_items ) {
9778 m.i_clear( fdest );
9779 }
9780
9781 if( src_items > 0 ) { // Move the stuff inside.
9782 if( dst_item_ok && src_item_ok ) {
9783 // Assume contents of both cells are legal, so we can just swap contents.
9784 std::list<item> temp;
9785 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
9786 std::back_inserter( temp ) );
9787 m.i_clear( fpos );
9788 for( auto item_iter = m.i_at( fdest ).begin();
9789 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
9790 m.i_at( fpos ).insert( *item_iter );
9791 }
9792 m.i_clear( fdest );
9793 for( auto &cur_item : temp ) {
9794 m.i_at( fdest ).insert( cur_item );
9795 }
9796 } else {
9797 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
9798 }
9799 }
9800
9801 if( shifting_furniture ) {
9802 // We didn't move
9803 tripoint d_sum = u.grab_point + dp;
9804 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
9805 u.grab_point = d_sum; // furniture moved relative to us
9806 } else { // we pushed furniture out of reach
9807 add_msg( _( "You let go of the %s." ), furntype.name() );
9808 u.grab( OBJECT_NONE );
9809 }
9810 return true; // We moved furniture but stayed still.
9811 }
9812
9813 if( pushing_furniture && m.impassable( fpos ) ) {
9814 // Not sure how that chair got into a wall, but don't let player follow.
9815 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
9816 furntype.name(), m.tername( fdest ) );
9817 u.grab( OBJECT_NONE );
9818 return true;
9819 }
9820
9821 return false;
9822}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4064
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:663
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:4979
void insert(const item &newitem) override
Definition: map.cpp:157
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5465
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5339
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5373
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5379
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5352
std::string tername(const tripoint &p) const
Definition: map.cpp:1709
void i_clear(const tripoint &p)
Definition: map.cpp:4128
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1360
bool has_floor(const tripoint &p) const
Definition: map.cpp:2007
tripoint grab_point
Definition: player.h:591
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1095
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:511
bool has_flag(const std::string &flag) const
Definition: mapdata.h:415

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 9824 of file game.cpp.

9825{
9826 if( u.get_grab_type() == OBJECT_NONE ) {
9827 return false;
9828 }
9829
9830 if( dp.z != 0 ) {
9831 // No dragging stuff up/down stairs yet!
9832 return false;
9833 }
9834
9835 // vehicle: pulling, pushing, or moving around the grabbed object.
9836 if( u.get_grab_type() == OBJECT_VEHICLE ) {
9837 return grabbed_veh_move( dp );
9838 }
9839
9840 if( u.get_grab_type() == OBJECT_FURNITURE ) {
9841 return grabbed_furn_move( dp );
9842 }
9843
9844 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
9846 u.grab( OBJECT_NONE );
9847 return false;
9848}
object_type get_grab_type() const
Definition: avatar.cpp:671
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:9652
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150
151 // Grabbed part has to stay at distance 1 to the player
152 // and in roughly the same direction.
153 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
154 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
155 const tripoint expected_pos = u.pos() + dp + from;
156 const tripoint actual_dir = expected_pos - new_part_pos;
157
158 grabbed_vehicle->adjust_zlevel( 1, dp );
159
160 // Set player location to illegal value so it can't collide with vehicle.
161 const tripoint player_prev = u.pos();
163 std::vector<veh_collision> colls;
164 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
165 u.setpos( player_prev );
166 if( !colls.empty() ) {
167 blocker_name = colls.front().target_name;
168 }
169 return failed ? tripoint_zero : actual_dir;
170 };
171
172 // First try the move as intended
173 // But if that fails and the move is a zig-zag, try to recover:
174 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
175 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
176 if( final_dp_veh == tripoint_zero && zigzag ) {
177 final_dp_veh = get_move_dir( -prev_grab, -dp );
178 next_grab = -dp;
179 }
180
181 if( final_dp_veh == tripoint_zero ) {
182 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
183 u.grab_point = prev_grab;
184 return true;
185 }
186
187 u.grab_point = next_grab;
188
189 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
190
191 if( grabbed_vehicle ) {
192 grabbed_vehicle->shift_zlevel();
193 grabbed_vehicle->check_falling_or_floating();
194 } else {
195 debugmsg( "Grabbed vehicle disappeared" );
196 return false;
197 }
198
199 for( int p : wheel_indices ) {
200 if( one_in( 2 ) ) {
201 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
202 grabbed_vehicle->handle_trap( wheel_p, p );
203 }
204 }
205
206 return false;
207
208}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1119
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1780
units::angle dir() const
Definition: tileray.cpp:74
void init(const point &ad)
Definition: tileray.cpp:27
void turn(units::angle deg)
const point & pivot_point() const
Definition: vehicle.cpp:5826
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3281
void precalc_mounts(int idir, units::angle dir, const point &pivot)
Definition: vehicle.cpp:3150
bool valid_wheel_config() const
Definition: vehicle.cpp:4459
units::mass total_mass() const
Definition: vehicle.cpp:3306
std::vector< int > wheelcache
Definition: vehicle.h:1818
void check_falling_or_floating()
tileray face
Definition: vehicle.h:1948
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6968
int part_count() const
Definition: vehicle.cpp:7075
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
monster * get_pet(int p) const
Definition: vehicle.cpp:3262
vehicle_part & part(int part_num)
Definition: vehicle.cpp:7080
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3286
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1927
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:273
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:371

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1516 of file handle_action.cpp.

1517{
1518 std::string action;
1519 input_context ctxt;
1521 user_turn current_turn;
1522 // Check if we have an auto-move destination
1523 if( u.has_destination() ) {
1525 if( act == ACTION_NULL ) {
1526 add_msg( m_info, _( "Auto-move canceled" ) );
1528 return false;
1529 }
1530 } else if( u.has_destination_activity() ) {
1531 // starts destination activity after the player successfully reached his destination
1533 return false;
1534 } else {
1535 // No auto-move, ask player for input
1536 ctxt = get_player_input( action );
1537 }
1538
1539 const optional_vpart_position vp = m.veh_at( u.pos() );
1540 bool veh_ctrl = !u.is_dead_state() &&
1541 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1542
1543 // If performing an action with right mouse button, co-ordinates
1544 // of location clicked.
1545 cata::optional<tripoint> mouse_target;
1546
1547 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1548 uquit = QUIT_DIED;
1549 return false;
1550 }
1551
1552 if( act == ACTION_NULL ) {
1554
1555 if( act == ACTION_KEYBINDINGS ) {
1556 // already handled by input context
1557 return false;
1558 }
1559
1560 if( act == ACTION_MAIN_MENU ) {
1561 if( uquit == QUIT_WATCH ) {
1562 return false;
1563 }
1564 // No auto-move actions have or can be set at this point.
1566 destination_preview.clear();
1568 if( act == ACTION_NULL ) {
1569 return false;
1570 }
1571 }
1572
1573 if( act == ACTION_ACTIONMENU ) {
1574 if( uquit == QUIT_WATCH ) {
1575 return false;
1576 }
1577 // No auto-move actions have or can be set at this point.
1579 destination_preview.clear();
1581 if( act == ACTION_NULL ) {
1582 return false;
1583 }
1584#if defined(__ANDROID__)
1585 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1586 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1587 }
1588#endif
1589 }
1590
1591 if( act == ACTION_KEYBINDINGS ) {
1593 destination_preview.clear();
1594 act = ctxt.display_menu( true );
1595 if( act == ACTION_NULL ) {
1596 return false;
1597 }
1598 }
1599
1602 }
1603
1604 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1605 // Mouse button click
1606 if( veh_ctrl ) {
1607 // No mouse use in vehicle
1608 return false;
1609 }
1610
1611 if( u.is_dead_state() ) {
1612 // do not allow mouse actions while dead
1613 return false;
1614 }
1615
1616 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1617 if( !mouse_pos ) {
1618 return false;
1619 } else if( !u.sees( *mouse_pos ) ) {
1620 // Not clicked in visible terrain
1621 return false;
1622 }
1623 mouse_target = mouse_pos;
1624
1625 if( act == ACTION_SELECT ) {
1626 // Note: The following has the potential side effect of
1627 // setting auto-move destination state in addition to setting
1628 // act.
1629 if( !try_get_left_click_action( act, *mouse_target ) ) {
1630 return false;
1631 }
1632 } else if( act == ACTION_SEC_SELECT ) {
1633 if( !try_get_right_click_action( act, *mouse_target ) ) {
1634 return false;
1635 }
1636 }
1637 } else if( act != ACTION_TIMEOUT ) {
1638 // act has not been set for an auto-move, so clearing possible
1639 // auto-move destinations. Since initializing an auto-move with
1640 // the mouse may span across multiple actions, we do not clear the
1641 // auto-move destination if the action is only a timeout, as this
1642 // would require the user to double click quicker than the
1643 // timeout delay.
1645 destination_preview.clear();
1646 }
1647 }
1648
1649 if( act == ACTION_NULL ) {
1650 const input_event &&evt = ctxt.get_raw_input();
1651 if( !evt.sequence.empty() ) {
1652 const int ch = evt.get_first_input();
1653 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1654 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1655 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1656 if( const cata::optional<std::string> hint =
1658 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1659 "the current context." ),
1660 *hint );
1661 }
1662 }
1663 }
1664 return false;
1665 }
1666
1667 // This has no action unless we're in a special game mode.
1668 gamemode->pre_action( act );
1669
1670 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1671
1672 int before_action_moves = u.moves;
1673
1674 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1675 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1676 switch( act ) {
1679 break;
1680
1681 case ACTION_CENTER:
1684 break;
1685
1686 case ACTION_SHIFT_N:
1687 case ACTION_SHIFT_NE:
1688 case ACTION_SHIFT_E:
1689 case ACTION_SHIFT_SE:
1690 case ACTION_SHIFT_S:
1691 case ACTION_SHIFT_SW:
1692 case ACTION_SHIFT_W:
1693 case ACTION_SHIFT_NW: {
1694 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1703 };
1705 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1706 }
1707 break;
1708
1709 case ACTION_LOOK:
1710 look_around();
1711 break;
1712
1713 case ACTION_KEYBINDINGS:
1714 // already handled by input context
1715 break;
1716
1717 default:
1718 break;
1719 }
1720 }
1721
1722 // actions allowed only while alive
1723 if( !u.is_dead_state() ) {
1724 switch( act ) {
1725 case ACTION_NULL:
1726 case NUM_ACTIONS:
1727 break; // dummy entries
1728 case ACTION_ACTIONMENU:
1729 case ACTION_MAIN_MENU:
1730 case ACTION_KEYBINDINGS:
1731 break; // handled above
1732
1733 case ACTION_TIMEOUT:
1734 if( check_safe_mode_allowed( false ) ) {
1735 u.pause();
1736 }
1737 break;
1738
1739 case ACTION_PAUSE:
1740 if( check_safe_mode_allowed() ) {
1741 u.pause();
1742 }
1743 break;
1744
1745 case ACTION_CYCLE_MOVE:
1747 break;
1748
1749 case ACTION_RESET_MOVE:
1751 break;
1752
1753 case ACTION_TOGGLE_RUN:
1755 break;
1756
1759 break;
1760
1763 break;
1764
1765 case ACTION_MOVE_FORTH:
1767 case ACTION_MOVE_RIGHT:
1769 case ACTION_MOVE_BACK:
1771 case ACTION_MOVE_LEFT:
1773 if( !u.get_value( "remote_controlling" ).empty() &&
1777 } else if( veh_ctrl ) {
1778 // vehicle control uses x for steering and y for ac/deceleration,
1779 // so no rotation needed
1781 } else {
1783 if( auto_travel_mode && !u.is_auto_moving() ) {
1784 for( int i = 0; i < SEEX; i++ ) {
1785 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1786 u.posy() + dest_delta.y * ( SEEX - i ),
1787 u.posz() );
1789 auto_travel_destination,
1791 u.get_path_avoid() );
1792 if( !destination_preview.empty() ) {
1795 break;
1796 }
1797 }
1800 if( dest_next == point_zero ) {
1802 }
1803 dest_delta = dest_next;
1804 }
1805 if( !avatar_action::move( u, m, dest_delta ) ) {
1806 // auto-move should be canceled due to a failed move or obstacle
1808 }
1809 }
1810 break;
1811 case ACTION_MOVE_DOWN:
1812 if( u.is_mounted() ) {
1813 auto mon = u.mounted_creature.get();
1814 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1815 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1816 break;
1817 }
1818 }
1819 if( !u.in_vehicle ) {
1820 vertical_move( -1, false );
1821 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1823 }
1824 break;
1825
1826 case ACTION_MOVE_UP:
1827 if( u.is_mounted() ) {
1828 auto mon = u.mounted_creature.get();
1829 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1830 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1831 break;
1832 }
1833 }
1834 if( !u.in_vehicle ) {
1835 vertical_move( 1, false );
1836 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1838 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1839 !vp->vehicle().has_sufficient_rotorlift() ) {
1840 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1841 }
1842 break;
1843
1844 case ACTION_OPEN:
1846 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1847 } else if( u.is_mounted() ) {
1848 add_msg( m_info, _( "You can't open things while you're riding." ) );
1849 } else {
1850 open();
1851 }
1852 break;
1853
1854 case ACTION_CLOSE:
1856 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1857 } else if( u.is_mounted() ) {
1858 auto mon = u.mounted_creature.get();
1859 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1860 add_msg( m_info, _( "You can't close things while you're riding." ) );
1861 }
1862 } else if( mouse_target ) {
1863 doors::close_door( m, u, *mouse_target );
1864 } else {
1865 close();
1866 }
1867 break;
1868
1869 case ACTION_SMASH:
1870 if( veh_ctrl ) {
1871 handbrake();
1872 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1873 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1874 } else {
1875 smash();
1876 }
1877 break;
1878
1879 case ACTION_EXAMINE:
1881 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1882 } else if( mouse_target ) {
1883 examine( *mouse_target );
1884 } else {
1885 examine();
1886 }
1887 break;
1888
1889 case ACTION_ADVANCEDINV:
1891 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1892 } else if( u.is_mounted() ) {
1893 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1894 } else {
1896 }
1897 break;
1898
1899 case ACTION_PICKUP:
1901 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1902 } else if( u.is_mounted() ) {
1903 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1904 } else if( mouse_target ) {
1905 pickup( *mouse_target );
1906 } else {
1907 pickup();
1908 }
1909 break;
1910
1911 case ACTION_PICKUP_FEET:
1913 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1914 } else {
1915 pickup_feet();
1916 }
1917 break;
1918
1919 case ACTION_GRAB:
1921 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1922 } else if( u.is_mounted() ) {
1923 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1924 } else {
1925 grab();
1926 }
1927 break;
1928
1929 case ACTION_HAUL:
1931 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1932 } else if( u.is_mounted() ) {
1933 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1934 } else {
1935 haul();
1936 }
1937 break;
1938
1939 case ACTION_BUTCHER:
1941 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1942 } else if( u.is_mounted() ) {
1943 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1944 } else {
1945 butcher();
1946 }
1947 break;
1948
1949 case ACTION_CHAT:
1950 chat();
1951 break;
1952
1953 case ACTION_PEEK:
1955 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1956 } else if( u.is_mounted() ) {
1957 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1958 } else {
1959 peek();
1960 }
1961 break;
1962
1963 case ACTION_LIST_ITEMS:
1965 break;
1966
1967 case ACTION_ZONES:
1968 zones_manager();
1969 break;
1970
1971 case ACTION_LOOT:
1972 loot();
1973 break;
1974
1975 case ACTION_INVENTORY:
1977 break;
1978
1979 case ACTION_COMPARE:
1981 break;
1982
1983 case ACTION_ORGANIZE:
1985 break;
1986
1987 case ACTION_USE:
1988 // Shell-users are presumed to be able to mess with their inventories, etc
1989 // while in the shell. Eating, gear-changing, and item use are OK.
1991 break;
1992
1993 case ACTION_USE_WIELDED:
1994 u.use_wielded();
1995 break;
1996
1997 case ACTION_WEAR:
1998 wear();
1999 break;
2000
2001 case ACTION_TAKE_OFF:
2002 takeoff();
2003 break;
2004
2005 case ACTION_EAT:
2006 if( !avatar_action::eat_here( u ) ) {
2008 }
2009 break;
2010
2012 if( !avatar_action::eat_here( u ) ) {
2014 }
2015 break;
2016
2017 case ACTION_READ:
2018 // Shell-users are presumed to have the book just at an opening and read it that way
2019 read();
2020 break;
2021
2022 case ACTION_WIELD:
2024 break;
2025
2026 case ACTION_PICK_STYLE:
2027 u.martial_arts_data->pick_style( u );
2028 break;
2029
2030 case ACTION_RELOAD_ITEM:
2032 break;
2033
2036 break;
2037
2040 break;
2041
2042 case ACTION_UNLOAD:
2044 break;
2045
2046 case ACTION_MEND:
2048 break;
2049
2050 case ACTION_THROW: {
2051 item_location loc;
2052 avatar_action::plthrow( g->u, loc );
2053 break;
2054 }
2055
2056 case ACTION_FIRE:
2057 fire();
2058 break;
2059
2060 case ACTION_CAST_SPELL:
2061 cast_spell();
2062 break;
2063
2064 case ACTION_FIRE_BURST: {
2065 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2067 }
2068 break;
2069 }
2070
2072 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2073 if( u.weapon.gun_all_modes().size() > 1 ) {
2075 } else {
2076 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2077 }
2078 }
2079 break;
2080
2082 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2084 }
2085 break;
2086
2087 case ACTION_DROP:
2088 // You CAN drop things to your own tile while in the shell.
2089 drop();
2090 break;
2091
2092 case ACTION_DIR_DROP:
2094 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2095 } else {
2097 }
2098 break;
2099 case ACTION_BIONICS:
2100 u.power_bionics();
2101 break;
2102 case ACTION_MUTATIONS:
2104 break;
2105
2106 case ACTION_SORT_ARMOR:
2107 u.sort_armor();
2108 break;
2109
2110 case ACTION_WAIT:
2111 wait();
2112 break;
2113
2114 case ACTION_CRAFT:
2116 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2117 } else if( u.is_mounted() ) {
2118 add_msg( m_info, _( "You can't craft while you're riding." ) );
2119 } else {
2120 u.craft();
2121 }
2122 break;
2123
2124 case ACTION_RECRAFT:
2126 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2127 } else if( u.is_mounted() ) {
2128 add_msg( m_info, _( "You can't craft while you're riding." ) );
2129 } else {
2130 u.recraft();
2131 }
2132 break;
2133
2134 case ACTION_LONGCRAFT:
2136 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2137 } else if( u.is_mounted() ) {
2138 add_msg( m_info, _( "You can't craft while you're riding." ) );
2139 } else {
2140 u.long_craft();
2141 }
2142 break;
2143
2144 case ACTION_DISASSEMBLE:
2145 if( u.controlling_vehicle ) {
2146 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2147 } else if( u.is_mounted() ) {
2148 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2149 } else {
2151 }
2152 break;
2153
2154 case ACTION_CONSTRUCT:
2155 if( u.in_vehicle ) {
2156 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2157 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2158 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2159 } else if( u.is_mounted() ) {
2160 add_msg( m_info, _( "You can't construct while you're riding." ) );
2161 } else {
2162 construction_menu( false );
2163 }
2164 break;
2165
2166 case ACTION_SLEEP:
2167 if( veh_ctrl ) {
2168 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2169 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2170 _( "new default binding is '^'." ) ) );
2171 } else {
2172 sleep();
2173 }
2174 break;
2175
2178 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2179 } else if( u.is_mounted() ) {
2180 u.dismount();
2181 } else {
2183 }
2184 break;
2185
2188 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2189 break;
2190
2192 if( safe_mode == SAFE_MODE_OFF ) {
2194 mostseen = 0;
2195 add_msg( m_info, _( "Safe mode ON!" ) );
2196 } else {
2199 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2200 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2201 }
2205 }
2206 break;
2207
2209 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2210 add_msg( m_info, autosafemode_option.value_as<bool>()
2211 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2212 autosafemode_option.setNext();
2213 break;
2214 }
2215
2217 if( safe_mode == SAFE_MODE_STOP ) {
2218 add_msg( m_info, _( "Ignoring enemy!" ) );
2219 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2220 monster &critter = *elem;
2221 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2222 }
2224 } else if( u.has_effect( effect_laserlocked ) ) {
2225 if( u.has_trait( trait_PROF_CHURL ) ) {
2226 add_msg( m_warning, _( "You make the sign of the cross." ) );
2227 } else {
2228 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2229 }
2232 }
2233 break;
2234
2236 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2238 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2240 mostseen = 0;
2241 } else {
2242 get_safemode().show();
2243 }
2244 break;
2245
2246 case ACTION_SUICIDE:
2247 if( query_yn( _( "Commit suicide?" ) ) ) {
2248 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2249 u.apply_damage( &u, body_part_head, 99999 );
2250 u.moves = 0;
2251 u.place_corpse();
2253 }
2254 }
2255 break;
2256
2257 case ACTION_SAVE:
2258 if( query_yn( _( "Save and quit?" ) ) ) {
2259 if( save() ) {
2260 u.moves = 0;
2261 uquit = QUIT_SAVED;
2262 }
2263 }
2264 break;
2265
2266 case ACTION_QUICKSAVE:
2267 quicksave();
2268 return false;
2269
2270 case ACTION_QUICKLOAD:
2271 quickload();
2272 return false;
2273
2274 case ACTION_PL_INFO:
2276 break;
2277
2278 case ACTION_MAP:
2280 break;
2281
2282 case ACTION_SKY:
2283 if( m.is_outside( u.pos() ) ) {
2285 } else {
2286 add_msg( m_info, _( "You can't see the sky from here." ) );
2287 }
2288 break;
2289
2290 case ACTION_MISSIONS:
2291 list_missions();
2292 break;
2293
2294 case ACTION_SCORES:
2296 break;
2297
2298 case ACTION_DIARY:
2300 break;
2301
2302 case ACTION_FACTIONS:
2303 faction_manager_ptr->display();
2304 break;
2305
2306 case ACTION_MORALE:
2307 u.disp_morale();
2308 break;
2309
2310 case ACTION_MESSAGES:
2312 break;
2313
2314 case ACTION_HELP:
2316 break;
2317
2318 case ACTION_OPTIONS:
2319 get_options().show( true );
2320 break;
2321
2322 case ACTION_AUTOPICKUP:
2324 break;
2325
2326 case ACTION_AUTONOTES:
2328 break;
2329
2330 case ACTION_SAFEMODE:
2331 get_safemode().show();
2332 break;
2333
2336 break;
2337
2338 case ACTION_COLOR:
2339 all_colors.show_gui();
2340 break;
2341
2342 case ACTION_WORLD_MODS:
2343 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2344 break;
2345
2346 case ACTION_DEBUG:
2348 break; //don't do anything when sharing and not debugger
2349 }
2351 break;
2352
2355 break;
2356
2359 break;
2360
2363 break;
2364
2367 break;
2368
2370 get_options().get_option( "AUTO_FEATURES" ).setNext();
2371 get_options().save();
2372 //~ Auto Features are now ON/OFF
2373 add_msg( _( "%s are now %s." ),
2374 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2375 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2376 break;
2377
2379 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2380 get_options().save();
2381 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2382 add_msg( _( "%s is now set to %s." ),
2383 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2384 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2385 break;
2386
2388 get_options().get_option( "AUTO_MINING" ).setNext();
2389 get_options().save();
2390 //~ Auto Mining is now ON/OFF
2391 add_msg( _( "%s is now %s." ),
2392 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2393 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2394 break;
2395
2397 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2398 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2399 u.set_value( "THIEF_MODE_KEEP", "YES" );
2400 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2401 add_msg( _( "You will not pick up other peoples belongings." ) );
2402 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2403 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2404 u.set_value( "THIEF_MODE_KEEP", "YES" );
2405 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2406 add_msg( _( "You will pick up also those things that belong to others!" ) );
2407 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2408 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2409 u.set_value( "THIEF_MODE_KEEP", "NO" );
2410 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2411 add_msg( _( "You will be reminded not to steal." ) );
2412 } else {
2413 // ERROR
2414 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2415 }
2416 break;
2417
2419 get_options().get_option( "AUTO_FORAGING" ).setNext();
2420 get_options().save();
2421 //~ Auto Foraging is now set to x
2422 add_msg( _( "%s is now set to %s." ),
2423 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2424 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2425 break;
2426
2428 get_options().get_option( "AUTO_PICKUP" ).setNext();
2429 get_options().save();
2430 //~ Auto pickup is now set to x
2431 add_msg( _( "%s is now set to %s." ),
2432 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2433 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2434 break;
2435
2438 break; //don't do anything when sharing and not debugger
2439 }
2440 display_scent();
2441 break;
2442
2445 break; //don't do anything when sharing and not debugger
2446 }
2447 display_scent();
2448 break;
2449
2452 break; //don't do anything when sharing and not debugger
2453 }
2455 break;
2458 break; //don't do anything when sharing and not debugger
2459 }
2461 break;
2464 break; //don't do anything when sharing and not debugger
2465 }
2467 break;
2468
2471 break; //don't do anything when sharing and not debugger
2472 }
2474 break;
2475
2478 break; //don't do anything when sharing and not debugger
2479 }
2481 break;
2482
2485 break; //don't do anything when sharing and not debugger
2486 }
2488 break;
2489
2491 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2492 break;
2493
2496 break;
2497
2500 break; //don't do anything when sharing and not debugger
2501 }
2503 if( debug_mode ) {
2504 add_msg( m_info, _( "Debug mode ON!" ) );
2505 } else {
2506 add_msg( m_info, _( "Debug mode OFF!" ) );
2507 }
2508 break;
2509
2510 case ACTION_ZOOM_IN:
2511 zoom_in();
2513 break;
2514
2515 case ACTION_ZOOM_OUT:
2516 zoom_out();
2518 break;
2519
2520 case ACTION_ITEMACTION:
2522 break;
2523
2524 case ACTION_AUTOATTACK:
2526 break;
2527
2528 default:
2529 break;
2530 }
2531 }
2532 if( act != ACTION_TIMEOUT ) {
2533 u.mod_moves( -current_turn.moves_elapsed() );
2534 }
2535 gamemode->post_action( act );
2536
2537 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2538 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2539 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2540 return ( !u.is_dead_state() );
2541}
cata::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:474
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:352
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:423
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:947
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:512
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:660
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:267
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:121
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:99
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:199
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:181
@ ACTION_READ
Open the read menu.
Definition: action.h:153
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:313
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:51
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:291
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:149
@ ACTION_SMASH
Smash something.
Definition: action.h:103
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:135
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:227
@ ACTION_HELP
Display help screen.
Definition: action.h:253
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:251
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:125
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:297
@ ACTION_USE
Open the use menu.
Definition: action.h:141
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:229
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:123
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:281
@ ACTION_OPTIONS
Display options window.
Definition: action.h:261
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:41
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:157
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:205
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:43
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:189
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:151
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:249
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:24
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:63
@ ACTION_CHAT
Chat with something.
Definition: action.h:117
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:163
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:57
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:243
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:265
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:155
@ ACTION_THROW
Open the throw menu.
Definition: action.h:169
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:309
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:133
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:217
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:69
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:137
@ ACTION_SCORES
Display scores screen.
Definition: action.h:245
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:115
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:31
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:67
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:329
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:29
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:255
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:327
@ ACTION_WAIT
Open wait menu.
Definition: action.h:197
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:293
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:207
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:127
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:279
@ ACTION_MAP
Display over-map.
Definition: action.h:239
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:167
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:219
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:143
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:237
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:285
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:311
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:173
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:185
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:211
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:225
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:59
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:299
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:307
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:213
@ ACTION_COLOR
Open color manager.
Definition: action.h:269
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:39
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:65
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:247
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:111
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:49
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:179
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:183
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:191
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:61
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:241
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:171
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:37
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:47
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:187
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:113
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:45
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:209
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:295
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:53
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:177
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:263
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:231
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:331
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:289
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:175
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:165
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:201
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:147
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:109
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:305
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:271
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:287
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:139
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:55
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:303
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:101
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:161
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:159
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:107
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:203
@ ACTION_DISTRACTION_MANAGER
Open distraction manager.
Definition: action.h:273
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:145
@ ACTION_DIARY
Display diary window.
Definition: action.h:257
void create_advanced_inv()
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
const bodypart_str_id body_part_head("head")
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:367
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1525
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2561
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9951
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9965
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:145
void dismount()
Definition: character.cpp:1247
item weapon
Definition: character.h:1521
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1331
std::string get_value(const std::string &key) const
Definition: creature.cpp:1341
void mod_moves(int nmoves)
Definition: creature.cpp:1408
void cycle_move_mode()
Definition: avatar.cpp:1180
void toggle_map_memory()
Definition: avatar.cpp:121
void toggle_crouch_mode()
Definition: avatar.cpp:1164
void toggle_run_mode()
Definition: avatar.cpp:1155
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:995
void reset_move_mode()
Definition: avatar.cpp:1173
static void show_diary_ui(diary *c_diary)
Definition: diary_ui.cpp:164
void item_action_menu()
void display_radiation()
Definition: game.cpp:11381
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2404
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:8759
void pickup_feet()
Definition: game.cpp:5767
void zones_manager()
Definition: game.cpp:6237
int turnssincelastmon
Definition: game.h:1047
void display_visibility()
Definition: game.cpp:11295
void display_scent()
Definition: game.cpp:11260
bool save()
Returns false if saving failed.
Definition: game.cpp:2899
void butcher()
Definition: game.cpp:8441
void display_temperature()
Definition: game.cpp:11281
bool auto_travel_mode
Definition: game.h:1044
void zoom_out()
Definition: game.cpp:7187
void toggle_pixel_minimap()
Definition: game.cpp:518
void toggle_debug_hour_timer()
Definition: game.cpp:11327
void display_transparency()
Definition: game.cpp:11388
void list_items_monsters()
Definition: game.cpp:7365
cata::optional< tripoint > look_around(bool force_3d=false)
Definition: game.cpp:6712
void chat()
Definition: npctalk.cpp:394
void quickload()
Definition: game.cpp:11423
void pickup()
Definition: game.cpp:5745
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:10108
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11355
void control_vehicle()
Definition: game.cpp:5315
void peek()
Definition: game.cpp:5774
void drop()
Definition: game.cpp:8179
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2432
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:8697
void zoom_in()
Definition: game.cpp:7199
void toggle_fullscreen()
Definition: game.cpp:508
void display_vehicle_ai()
Definition: game.cpp:11288
void reload_tileset()
Definition: game.cpp:529
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:3147
void drop_in_direction()
Definition: game.cpp:8184
void display_help()
Definition: help.cpp:140
cata::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1338
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1299
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:999
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:415
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6388
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7779
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4727
bool is_gunmod() const
Definition: item.cpp:6418
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7698
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7770
bool is_outside(const tripoint &p) const
Definition: map.cpp:2574
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:256
short ignoring
Definition: monster.h:508
cOpt & get_option(const std::string &name)
Definition: options.cpp:3372
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2754
void show_adm()
Definition: panels.cpp:2282
void pause()
Definition: player.cpp:609
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:340
void sort_armor()
Draws the UI and handles player input for the armor re-ordering window.
void power_mutations()
Definition: mutation_ui.cpp:89
void use_wielded()
Uses the current wielded weapon.
Definition: player.cpp:3058
int movecounter
Definition: player.h:603
void power_bionics()
Generates and handles the UI for player interaction with installed bionics.
Definition: bionics_ui.cpp:528
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:351
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:360
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
cata::optional< construction_id > construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void rcdrive(const point &d)
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static void sleep()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void reload_wielded(bool prompt=false)
Reload wielded item.
void reload_item()
Prompt to reload some item.
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void wield()
Prompt to wield some item.
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void plthrow(avatar &you, item_location loc, const cata::optional< tripoint > &blind_throw_from_pos=cata::nullopt)
void reload_weapon(bool try_everything=true)
Reload a wielded gun/tool.
void mend(avatar &you, item_location loc)
void unload(avatar &you)
Prompts to unload some item.
void disp_info(Character &ch)
Handles and displays detailed character info for the '@' screen.
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void compare(player &p, const cata::optional< tripoint > &offset)
void common(avatar &you)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3754
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:142
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:281
static constexpr point point_north_east
Definition: point.h:277
static constexpr point point_north_west
Definition: point.h:283
An instance of an input, like a keypress etc.
Definition: input.h:95
std::vector< int > sequence
Definition: input.h:101
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:96
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIARY, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DISTRACTION_MANAGER, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, Character::apply_damage(), auto_travel_mode, avatar_action::autoattack(), bio_remote, body_part_head, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, crafting::disassemble(), Character::dismount(), character_display::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), avatar::get_avatar_diary(), input_context::get_coordinates(), get_delta_from_movement_action(), get_distraction_manager(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), avatar_action::reload_item(), reload_tileset(), avatar_action::reload_weapon(), avatar_action::reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), distraction_manager::distraction_manager_gui::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), diary::show_diary_ui(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), avatar_action::wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 2083 of file game.cpp.

2084{
2086 const std::string action = ctxt.handle_input( 0 );
2087 bool refresh = true;
2088 if( action == "pause" ) {
2090 cancel_activity_query( _( "Confirm:" ) );
2091 }
2092 } else if( action == "player_data" ) {
2094 } else if( action == "messages" ) {
2096 } else if( action == "help" ) {
2098 } else if( action != "HELP_KEYBINDINGS" ) {
2099 refresh = false;
2100 }
2101 if( refresh ) {
2104 }
2105}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1867
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:854
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), character_display::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2109 of file game.cpp.

2110{
2111 cata::optional<tripoint> liveview_pos;
2112
2113 do {
2114 action = ctxt.handle_input();
2115 if( action == "MOUSE_MOVE" ) {
2116 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2117 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2118 liveview_pos = mouse_pos;
2119 liveview.show( *liveview_pos );
2120 } else if( !mouse_pos ) {
2121 liveview_pos.reset();
2122 liveview.hide();
2123 }
2125 }
2126 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2127
2128 if( action != "TIMEOUT" ) {
2129 // Keyboard event, break out of animation loop
2130 liveview.hide();
2131 return false;
2132 }
2133
2134 // Mouse movement or un-handled key
2135 return true;
2136}
void reset() noexcept
Definition: optional.h:158
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 641 of file game.cpp.

642{
643 return gamemode && gamemode->id() != SGAME_NULL;
644}

References gamemode, and SGAME_NULL.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11395 of file game.cpp.

11396{
11398 last_save_timestamp = time( nullptr );
11399}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 397 of file game_inventory.cpp.

399{
401 title, radius, none_message );
402}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:334

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ is_core_data_loaded()

bool game::is_core_data_loaded ( ) const

Returns whether the core data is currently loaded.

Definition at line 441 of file game.cpp.

442{
444}
bool is_data_finalized() const
Returns whether the data is finalized and ready to be utilized.
Definition: init.h:167

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8827 of file game.cpp.

8828{
8829 return !( get_dangerous_tile( dest_loc ).empty() );
8830}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8849

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 4979 of file game.cpp.

4980{
4981 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
4982 critter_at( p ) == nullptr;
4983}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2477 of file game.cpp.

2478{
2479 if( uquit == QUIT_WATCH ) {
2480 // deny player movement and dodging
2481 u.moves = 0;
2482 // prevent pain from updating
2483 u.set_pain( 0 );
2484 // prevent dodging
2485 u.dodges_left = 0;
2486 return false;
2487 }
2488 if( uquit == QUIT_DIED ) {
2489 if( u.in_vehicle ) {
2490 m.unboard_vehicle( u.pos() );
2491 }
2492 u.place_corpse();
2493 return true;
2494 }
2495 if( uquit == QUIT_SUICIDE ) {
2496 if( u.in_vehicle ) {
2497 m.unboard_vehicle( u.pos() );
2498 }
2499 return true;
2500 }
2501 if( uquit != QUIT_NO ) {
2502 return true;
2503 }
2504 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2505 if( u.is_dead_state() ) {
2507 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2508 uquit = QUIT_WATCH;
2509 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2510 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2512 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2513 uquit = QUIT_DIED;
2514 } else {
2515 // Something funky happened here, just die.
2516 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2517 uquit = QUIT_DIED;
2518 }
2519 return is_game_over();
2520 }
2521 return false;
2522}
int dodges_left
Definition: character.h:559
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: player.cpp:972
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:194
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3738 of file game.cpp.

3739{
3740 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3741 get_option<int>( "SAFEMODEPROXIMITY" );
3742 return is_hostile_within( distance );
3743}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3750

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3745 of file game.cpp.

3746{
3748}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:196

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3750 of file game.cpp.

3751{
3752 for( auto &critter : u.get_visible_creatures( distance ) ) {
3753 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3754 return critter;
3755 }
3756 }
3757
3758 return nullptr;
3759}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:169

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 4985 of file game.cpp.

4986{
4987 return weather::is_in_sunlight( m, p, get_weather().weather_id );
4988}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3384 of file game.cpp.

3385{
3386 const tripoint diff( u.pos() + u.view_offset - p );
3387
3388 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3389 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3390}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 4990 of file game.cpp.

4991{
4992 return weather::is_sheltered( m, p );
4993}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6167 of file game.cpp.

6168{
6169 return zones_manager_open;
6170}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1079

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1519
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1249
void restack(player &p)
Definition: inventory.cpp:399
void unsort()
Definition: inventory.cpp:227
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult,
Creature source 
)

Definition at line 4402 of file game.cpp.

4404{
4405 std::vector<tripoint> traj;
4406 traj.clear();
4407 traj = line_to( s, t, 0, 0 );
4408 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4409 traj = continue_line( traj, force );
4410 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4411
4412 knockback( traj, stun, dam_mult, source );
4413}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult,
Creature source = nullptr 
)

Definition at line 4419 of file game.cpp.

4421{
4422 // TODO: make the force parameter actually do something.
4423 // the header file says higher force causes more damage.
4424 // perhaps that is what it should do?
4425
4426 // TODO: refactor this so it's not copy/pasted 3 times
4427 tripoint tp = traj.front();
4428 if( !critter_at( tp ) ) {
4429 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4430 return;
4431 }
4432 std::size_t force_remaining = traj.size();
4433 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4434 if( stun > 0 ) {
4435 targ->add_effect( effect_stunned, 1_turns * stun );
4436 add_msg( _( "%s was stunned!" ), targ->name() );
4437 }
4438 for( size_t i = 1; i < traj.size(); i++ ) {
4439 if( m.impassable( traj[i].xy() ) || m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) {
4440 targ->setpos( traj[i - 1] );
4441 force_remaining = traj.size() - i;
4442 if( stun != 0 ) {
4443 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4444 add_msg( _( "%s was stunned!" ), targ->name() );
4445 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4446 targ->apply_damage( source, bodypart_id( "torso" ), dam_mult * force_remaining );
4447 targ->check_dead_state();
4448 }
4449 m.bash( traj[i], 2 * dam_mult * force_remaining );
4450 break;
4451 } else if( critter_at( traj[i] ) ) {
4452 targ->setpos( traj[i - 1] );
4453 force_remaining = traj.size() - i;
4454 if( stun != 0 ) {
4455 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4456 add_msg( _( "%s was stunned!" ), targ->name() );
4457 }
4458 traj.erase( traj.begin(), traj.begin() + i );
4459 if( critter_at<monster>( traj.front() ) ) {
4460 add_msg( _( "%s collided with something else and sent it flying!" ),
4461 targ->name() );
4462 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4463 if( guy->male ) {
4464 add_msg( _( "%s collided with someone else and sent him flying!" ),
4465 targ->name() );
4466 } else {
4467 add_msg( _( "%s collided with someone else and sent her flying!" ),
4468 targ->name() );
4469 }
4470 } else if( u.pos() == traj.front() ) {
4471 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4472 }
4473 knockback( traj, stun, dam_mult, source );
4474 break;
4475 }
4476 targ->setpos( traj[i] );
4477 if( m.has_flag( "LIQUID", targ->pos() ) && targ->can_drown() && !targ->is_dead() ) {
4478 targ->die( source );
4479 if( u.sees( *targ ) ) {
4480 add_msg( _( "The %s drowns!" ), targ->name() );
4481 }
4482 }
4483 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4484 !targ->is_dead() ) {
4485 targ->die( source );
4486 if( u.sees( *targ ) ) {
4487 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4488 }
4489 }
4490 tp = traj[i];
4491 }
4492 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4493 if( stun > 0 ) {
4494 targ->add_effect( effect_stunned, 1_turns * stun );
4495 add_msg( _( "%s was stunned!" ), targ->name );
4496 }
4497 for( size_t i = 1; i < traj.size(); i++ ) {
4498 if( m.impassable( traj[i].xy() ) ||
4499 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4500 targ->setpos( traj[i - 1] );
4501 force_remaining = traj.size() - i;
4502 if( stun != 0 ) {
4503 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4504 if( targ->has_effect( effect_stunned ) ) {
4505 add_msg( _( "%s was stunned!" ), targ->name );
4506 }
4507
4508 std::array<bodypart_id, 8> bps = {{
4509 bodypart_id( "head" ),
4510 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4511 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4512 bodypart_id( "torso" ),
4513 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4514 }
4515 };
4516 for( const bodypart_id &bp : bps ) {
4517 if( one_in( 2 ) ) {
4518 targ->deal_damage( source, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4519 }
4520 }
4521 targ->check_dead_state();
4522 }
4523 m.bash( traj[i], 2 * dam_mult * force_remaining );
4524 break;
4525 } else if( critter_at( traj[i] ) ) {
4526 targ->setpos( traj[i - 1] );
4527 force_remaining = traj.size() - i;
4528 if( stun != 0 ) {
4529 add_msg( _( "%s was stunned!" ), targ->name );
4530 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4531 }
4532 traj.erase( traj.begin(), traj.begin() + i );
4533 const tripoint &traj_front = traj.front();
4534 if( critter_at<monster>( traj_front ) ) {
4535 add_msg( _( "%s collided with something else and sent it flying!" ),
4536 targ->name );
4537 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4538 if( guy->male ) {
4539 add_msg( _( "%s collided with someone else and sent him flying!" ),
4540 targ->name );
4541 } else {
4542 add_msg( _( "%s collided with someone else and sent her flying!" ),
4543 targ->name );
4544 }
4545 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4547 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4548 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4549 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4550 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4551 }
4552 knockback( traj, stun, dam_mult, source );
4553 break;
4554 }
4555 targ->setpos( traj[i] );
4556 tp = traj[i];
4557 }
4558 } else if( u.pos() == tp ) {
4559 if( stun > 0 ) {
4560 u.add_effect( effect_stunned, 1_turns * stun );
4561 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4562 "You were stunned for %d turns!",
4563 stun ),
4564 stun );
4565 }
4566 for( size_t i = 1; i < traj.size(); i++ ) {
4567 if( m.impassable( traj[i] ) ||
4568 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4569 u.setpos( traj[i - 1] );
4570 force_remaining = traj.size() - i;
4571 if( stun != 0 ) {
4572 if( u.has_effect( effect_stunned ) ) {
4573 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4574 "You were stunned AGAIN for %d turns!",
4575 force_remaining ),
4576 force_remaining );
4577 } else {
4578 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4579 "You were stunned for %d turns!",
4580 force_remaining ),
4581 force_remaining );
4582 }
4583 u.add_effect( effect_stunned, 1_turns * force_remaining );
4584 std::array<bodypart_id, 8> bps = {{
4585 bodypart_id( "head" ),
4586 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4587 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4588 bodypart_id( "torso" ),
4589 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4590 }
4591 };
4592 for( const bodypart_id &bp : bps ) {
4593 if( one_in( 2 ) ) {
4594 u.deal_damage( source, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4595 }
4596 }
4598 }
4599 m.bash( traj[i], 2 * dam_mult * force_remaining );
4600 break;
4601 } else if( critter_at( traj[i] ) ) {
4602 u.setpos( traj[i - 1] );
4603 force_remaining = traj.size() - i;
4604 if( stun != 0 ) {
4605 if( u.has_effect( effect_stunned ) ) {
4606 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4607 "You were stunned AGAIN for %d turns!",
4608 force_remaining ),
4609 force_remaining );
4610 } else {
4611 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4612 "You were stunned for %d turns!",
4613 force_remaining ),
4614 force_remaining );
4615 }
4616 u.add_effect( effect_stunned, 1_turns * force_remaining );
4617 }
4618 traj.erase( traj.begin(), traj.begin() + i );
4619 if( critter_at<monster>( traj.front() ) ) {
4620 add_msg( _( "You collided with something and sent it flying!" ) );
4621 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4622 if( guy->male ) {
4623 add_msg( _( "You collided with someone and sent him flying!" ) );
4624 } else {
4625 add_msg( _( "You collided with someone and sent her flying!" ) );
4626 }
4627 }
4628 knockback( traj, stun, dam_mult, source );
4629 break;
4630 }
4631 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4632 avatar_action::swim( m, u, u.pos() );
4633 } else {
4634 u.setpos( traj[i] );
4635 }
4636
4637 tp = traj[i];
4638 }
4639 }
4640}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8940
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8468
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:980
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, map::obstructed_by_vehicle_rotation(), one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3717 of file game.cpp.

3718{
3719 const float light = natural_light_level( zlev );
3720 return LIGHT_RANGE( light );
3721}
float natural_light_level(int zlev) const
Definition: game.cpp:3657
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_characters()

std::vector< std::string > game::list_active_characters ( )

Returns a list of currently active character saves.

Definition at line 2924 of file game.cpp.

2925{
2926 std::vector<std::string> saves;
2927 for( auto &worldsave : world_generator->active_world->world_saves ) {
2928 saves.push_back( worldsave.player_name() );
2929 }
2930 return saves;
2931}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7410 of file game.cpp.

7411{
7412 std::vector<map_item_stack> ground_items = item_list;
7413 int iInfoHeight = 0;
7414 int iMaxRows = 0;
7415 int width = 0;
7416 int max_name_width = 0;
7417
7418 //find max length of item name and resize window width
7419 for( const map_item_stack &cur_item : ground_items ) {
7420 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7421 if( item_len > max_name_width ) {
7422 max_name_width = item_len;
7423 }
7424 }
7425
7426 tripoint active_pos;
7427 map_item_stack *activeItem = nullptr;
7428
7429 catacurses::window w_items;
7430 catacurses::window w_items_border;
7431 catacurses::window w_item_info;
7432
7433 ui_adaptor ui;
7434 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7435 iInfoHeight = std::min( 25, TERMY / 2 );
7436 iMaxRows = TERMY - iInfoHeight - 2;
7437
7438 width = clamp( max_name_width, 45, TERMX / 3 );
7439
7440 const int offsetX = TERMX - width;
7441
7442 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7443 width - 2, point( offsetX + 1, 1 ) );
7444 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7445 width, point( offsetX, 0 ) );
7446 w_item_info = catacurses::newwin( iInfoHeight, width,
7447 point( offsetX, TERMY - iInfoHeight ) );
7448
7449 if( activeItem ) {
7450 centerlistview( active_pos, width );
7451 }
7452
7453 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7454 } );
7455 ui.mark_resize();
7456
7457 // use previously selected sorting method
7458 bool sort_radius = uistate.list_item_sort != 2;
7459 bool addcategory = !sort_radius;
7460
7461 // reload filter/priority settings on the first invocation, if they were active
7462 if( !uistate.list_item_init ) {
7465 }
7468 }
7471 }
7472 uistate.list_item_init = true;
7473 }
7474
7475 //this stores only those items that match our filter
7476 std::vector<map_item_stack> filtered_items =
7477 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7478 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7479 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7480 int iItemNum = ground_items.size();
7481
7482 const tripoint stored_view_offset = u.view_offset;
7483
7485
7486 int iActive = 0; // Item index that we're looking at
7487 bool refilter = true;
7488 int page_num = 0;
7489 int iCatSortNum = 0;
7490 int iScrollPos = 0;
7491 std::map<int, std::string> mSortCategory;
7492
7493 std::string action;
7494 input_context ctxt( "LIST_ITEMS" );
7495 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7496 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7497 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7498 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7499 ctxt.register_action( "PAGE_DOWN" );
7500 ctxt.register_action( "PAGE_UP" );
7501 ctxt.register_action( "NEXT_TAB" );
7502 ctxt.register_action( "PREV_TAB" );
7503 ctxt.register_action( "HELP_KEYBINDINGS" );
7504 ctxt.register_action( "QUIT" );
7505 ctxt.register_action( "FILTER" );
7506 ctxt.register_action( "RESET_FILTER" );
7507 ctxt.register_action( "EXAMINE" );
7508 ctxt.register_action( "COMPARE" );
7509 ctxt.register_action( "PRIORITY_INCREASE" );
7510 ctxt.register_action( "PRIORITY_DECREASE" );
7511 ctxt.register_action( "SORT" );
7512 ctxt.register_action( "TRAVEL_TO" );
7513
7515
7516 ui.on_redraw( [&]( const ui_adaptor & ) {
7517 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7518
7519 if( ground_items.empty() ) {
7520 wnoutrefresh( w_items_border );
7521 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7522 } else {
7523 int iStartPos = 0;
7524 werase( w_items );
7525 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7526 int iNum = 0;
7527 bool high = false;
7528 bool low = false;
7529 int index = 0;
7530 int iCatSortOffset = 0;
7531
7532 for( int i = 0; i < iStartPos; i++ ) {
7533 if( !mSortCategory[i].empty() ) {
7534 iNum++;
7535 }
7536 }
7537 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7538 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7539 high = true;
7540 low = false;
7541 } else if( index >= lowPStart + iCatSortOffset ) {
7542 high = false;
7543 low = true;
7544 } else {
7545 high = false;
7546 low = false;
7547 }
7548
7549 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7550 int iThisPage = 0;
7551 if( !mSortCategory[iNum].empty() ) {
7552 iCatSortOffset++;
7553 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7554 } else {
7555 if( iNum == iActive ) {
7556 iThisPage = page_num;
7557 }
7558 std::string sText;
7559 if( iter->vIG.size() > 1 ) {
7560 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7561 }
7562 sText += iter->example->tname();
7563 if( iter->vIG[iThisPage].count > 1 ) {
7564 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7565 }
7566
7567 nc_color col = c_light_green;
7568 if( iNum != iActive ) {
7569 if( high ) {
7570 col = c_yellow;
7571 } else if( low ) {
7572 col = c_red;
7573 } else {
7574 col = iter->example->color_in_inventory();
7575 }
7576 }
7577 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7578 const int numw = iItemNum > 9 ? 2 : 1;
7579 const int x = iter->vIG[iThisPage].pos.x;
7580 const int y = iter->vIG[iThisPage].pos.y;
7581 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7582 iNum == iActive ? c_light_green : c_light_gray,
7583 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7585 ++iter;
7586 }
7587 } else {
7588 ++iter;
7589 }
7590 iNum++;
7591 }
7592 iNum = 0;
7593 for( int i = 0; i < iActive; i++ ) {
7594 if( !mSortCategory[i].empty() ) {
7595 iNum++;
7596 }
7597 }
7598 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7599 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7600 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7601 werase( w_item_info );
7602
7603 if( iItemNum > 0 && activeItem ) {
7604 std::vector<iteminfo> vThisItem;
7605 std::vector<iteminfo> vDummy;
7606 activeItem->example->info( true, vThisItem );
7607
7608 item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
7609 dummy.without_getch = true;
7610 dummy.without_border = true;
7611
7612 draw_item_info( w_item_info, dummy );
7613 }
7614 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7615 wnoutrefresh( w_items_border );
7616 }
7617
7618 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7619 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7620
7621 if( iItemNum > 0 && activeItem ) {
7622 // print info window title: < item name >
7623 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7624 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7625 activeItem->example->display_name() );
7626 wprintw( w_item_info, " >" );
7627 }
7628
7629 wnoutrefresh( w_items );
7630 wnoutrefresh( w_item_info );
7631
7632 if( filter_type ) {
7633 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7634 }
7635 } );
7636
7637 cata::optional<tripoint> trail_start;
7638 cata::optional<tripoint> trail_end;
7639 bool trail_end_x = false;
7640 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7641 trail_end_x );
7642 add_draw_callback( trail_cb );
7643
7644 do {
7645 if( action == "COMPARE" && activeItem ) {
7646 game_menus::inv::compare( u, active_pos );
7647 } else if( action == "FILTER" ) {
7648 filter_type = item_filter_type::FILTER;
7649 ui.invalidate_ui();
7651 .title( _( "Filter:" ) )
7652 .width( 55 )
7653 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7654 .identifier( "item_filter" )
7655 .max_length( 256 )
7656 .edit( sFilter );
7657 refilter = true;
7658 addcategory = !sort_radius;
7660 filter_type = cata::nullopt;
7661 } else if( action == "RESET_FILTER" ) {
7662 sFilter.clear();
7663 filtered_items = ground_items;
7664 refilter = true;
7666 addcategory = !sort_radius;
7667 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7668 std::vector<iteminfo> vThisItem;
7669 std::vector<iteminfo> vDummy;
7670 activeItem->example->info( true, vThisItem );
7671
7672 item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
7673 vDummy );
7674 info_data.handle_scrolling = true;
7675
7677 return catacurses::newwin( TERMY, width - 5, point_zero );
7678 }, info_data );
7679 } else if( action == "PRIORITY_INCREASE" ) {
7680 filter_type = item_filter_type::HIGH_PRIORITY;
7681 ui.invalidate_ui();
7683 .title( _( "High Priority:" ) )
7684 .width( 55 )
7686 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7687 .identifier( "list_item_priority" )
7688 .max_length( 256 )
7689 .query_string();
7690 refilter = true;
7691 addcategory = !sort_radius;
7693 filter_type = cata::nullopt;
7694 } else if( action == "PRIORITY_DECREASE" ) {
7695 filter_type = item_filter_type::LOW_PRIORITY;
7696 ui.invalidate_ui();
7698 .title( _( "Low Priority:" ) )
7699 .width( 55 )
7701 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7702 .identifier( "list_item_downvote" )
7703 .max_length( 256 )
7704 .query_string();
7705 refilter = true;
7706 addcategory = !sort_radius;
7708 filter_type = cata::nullopt;
7709 } else if( action == "SORT" ) {
7710 if( sort_radius ) {
7711 sort_radius = false;
7712 addcategory = true;
7713 uistate.list_item_sort = 2; // list is sorted by category
7714 } else {
7715 sort_radius = true;
7716 uistate.list_item_sort = 1; // list is sorted by distance
7717 }
7718 highPEnd = -1;
7719 lowPStart = -1;
7720 iCatSortNum = 0;
7721
7722 mSortCategory.clear();
7723 refilter = true;
7724 } else if( action == "TRAVEL_TO" && activeItem ) {
7725 if( !u.sees( u.pos() + active_pos ) ) {
7726 add_msg( _( "You can't see that destination." ) );
7727 }
7728 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7729 u.get_path_avoid() );
7730 if( route.size() > 1 ) {
7731 route.pop_back();
7732 u.set_destination( route );
7733 break;
7734 } else {
7735 add_msg( m_info, _( "You can't travel there." ) );
7736 }
7737 }
7738 if( uistate.list_item_sort == 1 ) {
7739 ground_items = item_list;
7740 } else if( uistate.list_item_sort == 2 ) {
7741 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7742 }
7743
7744 if( refilter ) {
7745 refilter = false;
7746 filtered_items = filter_item_stacks( ground_items, sFilter );
7747 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7748 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7749 iActive = 0;
7750 page_num = 0;
7751 iItemNum = filtered_items.size();
7752 }
7753
7754 if( addcategory ) {
7755 addcategory = false;
7756 iCatSortNum = 0;
7757 mSortCategory.clear();
7758 if( highPEnd > 0 ) {
7759 mSortCategory[0] = _( "HIGH PRIORITY" );
7760 iCatSortNum++;
7761 }
7762 std::string last_cat_name;
7763 for( int i = std::max( 0, highPEnd );
7764 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7765 const std::string &cat_name = filtered_items[i].example->get_category().name();
7766 if( cat_name != last_cat_name ) {
7767 mSortCategory[i + iCatSortNum++] = cat_name;
7768 last_cat_name = cat_name;
7769 }
7770 }
7771 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7772 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7773 }
7774 if( !mSortCategory[0].empty() ) {
7775 iActive++;
7776 }
7777 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7778 }
7779
7780 if( action == "UP" ) {
7781 do {
7782 iActive--;
7783
7784 } while( !mSortCategory[iActive].empty() );
7785 iScrollPos = 0;
7786 page_num = 0;
7787 if( iActive < 0 ) {
7788 iActive = iItemNum - 1;
7789 }
7790 } else if( action == "DOWN" ) {
7791 do {
7792 iActive++;
7793
7794 } while( !mSortCategory[iActive].empty() );
7795 iScrollPos = 0;
7796 page_num = 0;
7797 if( iActive >= iItemNum ) {
7798 iActive = mSortCategory[0].empty() ? 0 : 1;
7799 }
7800 } else if( action == "RIGHT" ) {
7801 if( !filtered_items.empty() && activeItem ) {
7802 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7803 page_num = activeItem->vIG.size() - 1;
7804 }
7805 }
7806 } else if( action == "LEFT" ) {
7807 page_num = std::max( 0, page_num - 1 );
7808 } else if( action == "PAGE_UP" ) {
7809 iScrollPos--;
7810 } else if( action == "PAGE_DOWN" ) {
7811 iScrollPos++;
7812 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7813 u.view_offset = stored_view_offset;
7815 }
7816
7817 active_pos = tripoint_zero;
7818 activeItem = nullptr;
7819
7820 if( mSortCategory[iActive].empty() ) {
7821 auto iter = filtered_items.begin();
7822 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7823 if( mSortCategory[iNum].empty() ) {
7824 ++iter;
7825 }
7826 }
7827 if( iter != filtered_items.end() ) {
7828 active_pos = iter->vIG[page_num].pos;
7829 activeItem = &( *iter );
7830 }
7831 }
7832
7833 if( activeItem ) {
7834 centerlistview( active_pos, width );
7835 trail_start = u.pos();
7836 trail_end = u.pos() + active_pos;
7837 // Actually accessed from the terrain overlay callback `trail_cb` in the
7838 // call to `ui_manager::redraw`.
7839 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7840 trail_end_x = true;
7841 } else {
7842 u.view_offset = stored_view_offset;
7843 trail_start = trail_end = cata::nullopt;
7844 }
7846
7848
7849 action = ctxt.handle_input();
7850 } while( action != "QUIT" );
7851
7852 u.view_offset = stored_view_offset;
7853 return game::vmenu_ret::QUIT;
7854}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:145
std::string list_item_upvote
Definition: game.h:1057
std::string list_item_downvote
Definition: game.h:1058
std::string sFilter
Definition: game.h:1056
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7296
std::string info(bool showtext=false) const
Return all the information about the item and its type.
Definition: item.cpp:1104
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4042
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9699
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4465
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:120
int list_item_sort
Definition: uistate.h:117
bool list_item_downvote_active
Definition: uistate.h:123
bool list_item_init
Definition: uistate.h:125
bool list_item_filter_active
Definition: uistate.h:122
std::string list_item_filter
Definition: uistate.h:118
bool list_item_priority_active
Definition: uistate.h:124
std::string list_item_downvote
Definition: uistate.h:119
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const cata::optional< tripoint > &trail_start, const cata::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3237
uistatedata uistate
Definition: game.cpp:279
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7141
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, const point &p, const std::string &text)
void wprintw(const window &win, const std::string &text)
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, const point &offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, const point &pos, int height, int width)
Definition: output.cpp:524
void trim_and_print(const catacurses::window &w, const point &begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7365 of file game.cpp.

7366{
7367 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7368 // whole reality bubble
7369 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7370
7371 if( mons.empty() && items.empty() ) {
7372 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7373 return;
7374 }
7375
7376 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7377 const auto att_lhs = lhs->attitude_to( u );
7378 const auto att_rhs = rhs->attitude_to( u );
7379
7380 return att_lhs < att_rhs || ( att_lhs == att_rhs
7381 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7382 } );
7383
7384 // If the current list is empty, switch to the non-empty list
7386 if( items.empty() ) {
7387 uistate.vmenu_show_items = false;
7388 }
7389 } else if( mons.empty() ) {
7391 }
7392
7395 while( true ) {
7396 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7399 } else {
7400 break;
7401 }
7402 }
7403
7404 if( ret == game::vmenu_ret::FIRE ) {
7406 }
7408}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7856
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7410
vmenu_ret
Definition: game.h:795
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:7064
void temp_exit_fullscreen()
Definition: game.cpp:555
void reenter_fullscreen()
Definition: game.cpp:565
bool vmenu_show_items
Definition: uistate.h:121

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:844
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:213
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:192
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:182
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:177
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:187
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, const point &begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
#define BORDER_COLOR
Definition: output.h:135
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7856 of file game.cpp.

7857{
7858 const int iInfoHeight = 15;
7859 const int width = 45;
7860 int offsetX = 0;
7861 int iMaxRows = 0;
7862
7863 catacurses::window w_monsters;
7864 catacurses::window w_monsters_border;
7865 catacurses::window w_monster_info;
7866 catacurses::window w_monster_info_border;
7867
7868 Creature *cCurMon = nullptr;
7869 tripoint iActivePos;
7870
7871 bool hide_ui = false;
7872
7873 ui_adaptor ui;
7874 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7875 if( hide_ui ) {
7876 ui.position( point_zero, point_zero );
7877 } else {
7878 offsetX = TERMX - width;
7879 iMaxRows = TERMY - iInfoHeight - 1;
7880
7881 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
7882 1 ) );
7883 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
7884 0 ) );
7885 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
7886 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
7887 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
7888 TERMY - iInfoHeight ) );
7889
7890 if( cCurMon ) {
7891 centerlistview( iActivePos, width );
7892 }
7893
7894 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7895 }
7896 } );
7897 ui.mark_resize();
7898
7899 const int max_gun_range = u.weapon.gun_range( &u );
7900
7901 const tripoint stored_view_offset = u.view_offset;
7903
7904 int iActive = 0; // monster index that we're looking at
7905
7906 std::string action;
7907 input_context ctxt( "LIST_MONSTERS" );
7908 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7909 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7910 ctxt.register_action( "NEXT_TAB" );
7911 ctxt.register_action( "PREV_TAB" );
7912 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
7913 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
7914 ctxt.register_action( "QUIT" );
7915 if( bVMonsterLookFire ) {
7916 ctxt.register_action( "look" );
7917 ctxt.register_action( "fire" );
7918 }
7919 ctxt.register_action( "HELP_KEYBINDINGS" );
7920
7921 // first integer is the row the attitude category string is printed in the menu
7922 std::map<int, Creature::Attitude> mSortCategory;
7923
7924 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
7925 const auto attitude = monster_list[i]->attitude_to( u );
7926 if( attitude != last_attitude ) {
7927 mSortCategory[i + mSortCategory.size()] = attitude;
7928 last_attitude = attitude;
7929 }
7930 }
7931
7932 ui.on_redraw( [&]( const ui_adaptor & ) {
7933 if( !hide_ui ) {
7934 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
7935 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7936 true );
7937
7938 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
7939 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
7940
7941 if( monster_list.empty() ) {
7942 werase( w_monsters );
7943 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
7944 _( "You don't see any monsters around you!" ) );
7945 } else {
7946 werase( w_monsters );
7947
7948 const int iNumMonster = monster_list.size();
7949 const int iMenuSize = monster_list.size() + mSortCategory.size();
7950
7951 const int numw = iNumMonster > 999 ? 4 :
7952 iNumMonster > 99 ? 3 :
7953 iNumMonster > 9 ? 2 : 1;
7954
7955 // given the currently selected monster iActive. get the selected row
7956 int iSelPos = iActive;
7957 for( auto &ia : mSortCategory ) {
7958 int index = ia.first;
7959 if( index <= iSelPos ) {
7960 ++iSelPos;
7961 } else {
7962 break;
7963 }
7964 }
7965 int iStartPos = 0;
7966 // use selected row get the start row
7967 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
7968
7969 // get first visible monster and category
7970 int iCurMon = iStartPos;
7971 auto CatSortIter = mSortCategory.cbegin();
7972 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
7973 ++CatSortIter;
7974 --iCurMon;
7975 }
7976
7977 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
7978 for( int y = 0; y < endY; ++y ) {
7979 if( CatSortIter != mSortCategory.cend() ) {
7980 const int iCurPos = iStartPos + y;
7981 const int iCatPos = CatSortIter->first;
7982 if( iCurPos == iCatPos ) {
7983 const std::string cat_name = Creature::get_attitude_ui_data(
7984 CatSortIter->second ).first.translated();
7985 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
7986 ++CatSortIter;
7987 continue;
7988 }
7989 }
7990 // select current monster
7991 const auto critter = monster_list[iCurMon];
7992 const bool selected = iCurMon == iActive;
7993 ++iCurMon;
7994 if( critter->sees( g->u ) ) {
7995 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
7996 }
7997 bool is_npc = false;
7998 const monster *m = dynamic_cast<monster *>( critter );
7999 const npc *p = dynamic_cast<npc *>( critter );
8000 nc_color name_color = critter->basic_symbol_color();
8001
8002 if( selected ) {
8003 name_color = hilite( name_color );
8004 }
8005
8006 if( m != nullptr ) {
8007 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
8008 } else {
8009 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
8010 is_npc = true;
8011 }
8012
8013 if( selected && !get_safemode().empty() ) {
8014 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
8015
8016 std::string sSafemode;
8017 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8018 sSafemode = _( "<R>emove from safemode Blacklist" );
8019 } else {
8020 sSafemode = _( "<A>dd to safemode Blacklist" );
8021 }
8022
8023 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
8024 c_white, c_light_green, sSafemode );
8025 }
8026
8028 std::string sText;
8029
8030 if( m != nullptr ) {
8031 m->get_HP_Bar( color, sText );
8032 } else {
8033 std::tie( sText, color ) =
8034 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
8035 }
8036 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
8037
8038 if( m != nullptr ) {
8039 const auto att = m->get_attitude();
8040 sText = att.first;
8041 color = att.second;
8042 } else if( p != nullptr ) {
8043 sText = npc_attitude_name( p->get_attitude() );
8044 color = p->symbol_color();
8045 }
8046 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
8047
8048 const int mon_dist = rl_dist( u.pos(), critter->pos() );
8049 const int numd = mon_dist > 999 ? 4 :
8050 mon_dist > 99 ? 3 :
8051 mon_dist > 9 ? 2 : 1;
8052
8053 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
8054 selected ? c_light_green : c_light_gray,
8055 "%*d %s",
8056 numd, mon_dist,
8057 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
8058 }
8059
8060 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
8061 iActive + 1 );
8062 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
8063
8064 werase( w_monster_info );
8065 if( cCurMon ) {
8066 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
8067 }
8068
8069 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8070 true );
8071
8072 if( bVMonsterLookFire ) {
8073 mvwprintw( w_monster_info_border, point_east, "< " );
8074 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
8075 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
8076
8077 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8078 wprintw( w_monster_info_border, " " );
8079 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
8080 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
8081 }
8082 wprintw( w_monster_info_border, " >" );
8083 }
8084
8085 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
8086 point_south );
8087 }
8088
8089 wnoutrefresh( w_monsters_border );
8090 wnoutrefresh( w_monster_info_border );
8091 wnoutrefresh( w_monsters );
8092 wnoutrefresh( w_monster_info );
8093 }
8094 } );
8095
8096 cata::optional<tripoint> trail_start;
8097 cata::optional<tripoint> trail_end;
8098 bool trail_end_x = false;
8099 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
8100 trail_end_x );
8101 add_draw_callback( trail_cb );
8102
8103 do {
8104 if( action == "UP" ) {
8105 iActive--;
8106 if( iActive < 0 ) {
8107 if( monster_list.empty() ) {
8108 iActive = 0;
8109 } else {
8110 iActive = static_cast<int>( monster_list.size() ) - 1;
8111 }
8112 }
8113 } else if( action == "DOWN" ) {
8114 iActive++;
8115 if( iActive >= static_cast<int>( monster_list.size() ) ) {
8116 iActive = 0;
8117 }
8118 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
8119 u.view_offset = stored_view_offset;
8121 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
8122 const auto m = dynamic_cast<monster *>( cCurMon );
8123 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8124
8125 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8127 }
8128 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
8129 if( !get_safemode().empty() ) {
8130 const auto m = dynamic_cast<monster *>( cCurMon );
8131 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8132
8133 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8135 }
8136 } else if( action == "look" ) {
8137 hide_ui = true;
8138 ui.mark_resize();
8139 look_around();
8140 hide_ui = false;
8141 ui.mark_resize();
8142 } else if( action == "fire" ) {
8143 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8144 u.last_target = shared_from( *cCurMon );
8146 u.view_offset = stored_view_offset;
8147 return game::vmenu_ret::FIRE;
8148 }
8149 }
8150
8151 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8152 cCurMon = monster_list[iActive];
8153 iActivePos = cCurMon->pos() - u.pos();
8154 centerlistview( iActivePos, width );
8155 trail_start = u.pos();
8156 trail_end = cCurMon->pos();
8157 // Actually accessed from the terrain overlay callback `trail_cb` in the
8158 // call to `ui_manager::redraw`.
8159 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8160 trail_end_x = false;
8161 } else {
8162 cCurMon = nullptr;
8163 iActivePos = tripoint_zero;
8164 u.view_offset = stored_view_offset;
8165 trail_start = trail_end = cata::nullopt;
8166 }
8168
8170
8171 action = ctxt.handle_input();
8172 } while( action != "QUIT" );
8173
8174 u.view_offset = stored_view_offset;
8175
8176 return game::vmenu_ret::QUIT;
8177}
double recoil
Definition: character.h:561
nc_color symbol_color() const override
Color's character's tile's background.
Definition: character.cpp:6109
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1860
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4722
bool bVMonsterLookFire
Definition: game.h:1061
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7222
npc_attitude get_attitude() const
Definition: npc.cpp:3139
weak_ptr_fast< Creature > last_target
Definition: player.h:597
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2545
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, const point &p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2644 of file game.cpp.

2645{
2648 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2651
2652 using namespace std::placeholders;
2653
2654 const std::string worldpath = get_world_base_save_path() + "/";
2655 const std::string playerpath = worldpath + name.base_path();
2656
2657 // Now load up the master game data; factions (and more?)
2658 load_master();
2659 u = avatar();
2660 u.name = name.player_name();
2661 // This should be initialized more globally (in player/Character constructor)
2663 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2664 return false;
2665 }
2666
2668 u.get_avatar_diary()->load();
2669
2671
2672 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2673 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2674
2675#if defined(__ANDROID__)
2676 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2677 std::bind( &game::load_shortcuts, this, _1 ) );
2678#endif
2679
2680 // Now that the player's worn items are updated, their sight limits need to be
2681 // recalculated. (This would be cleaner if u.worn were private.)
2683
2684 if( !gamemode ) {
2685 gamemode = std::make_unique<special_game>();
2686 }
2687
2688 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2689 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2690
2691 init_autosave();
2692 get_auto_pickup().load_character(); // Load character auto pickup rules
2693 get_auto_notes_settings().load(); // Load character auto notes settings
2694 get_safemode().load_character(); // Load character safemode rules
2695 zone_manager::get_manager().load_zones(); // Load character world zones
2696 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2697 JsonIn jsin( stream );
2698 uistate.deserialize( jsin );
2699 } );
2700 reload_npcs();
2705 update_map( u );
2706 for( auto &e : u.inv_dump() ) {
2707 e->set_owner( g->u );
2708 }
2709 // legacy, needs to be here as we access the map.
2710 if( !u.getID().is_valid() ) {
2711 // player does not have a real id, so assign a new one,
2712 u.setID( assign_npc_id() );
2713 // The vehicle stores the IDs of the boarded players, so update it, too.
2714 if( u.in_vehicle ) {
2716 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2717 vp->part().passenger_id = u.getID();
2718 }
2719 }
2720 }
2721
2722 // populate calendar caches now, after active world is set, but before we do
2723 // anything else, to ensure they pick up the correct value from the save's
2724 // worldoptions
2725 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2726 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2727
2728 u.reset();
2729
2730 return true;
2731}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:466
std::vector< item * > inv_dump()
Definition: character.cpp:8964
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1703
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3622
Definition: json.h:177
Definition: avatar.h:55
void load_map_memory()
Definition: avatar.cpp:136
Helper class that fills the background and obscures all UIs below.
Definition: ui_manager.h:193
bool is_valid() const
Definition: character_id.h:19
void load()
Definition: diary.cpp:810
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:2006
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:979
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:2064
void load_master()
Definition: game.cpp:2613
void validate_mounted_npcs()
Definition: game.cpp:2021
character_id assign_npc_id()
Definition: game.cpp:3731
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11395
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:2040
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:278
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), avatar::get_avatar_diary(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), diary::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2620 of file game.cpp.

2621{
2622 world_generator->init();
2623 const WORLDPTR wptr = world_generator->get_world( world );
2624 if( !wptr ) {
2625 return false;
2626 }
2627 if( wptr->world_saves.empty() ) {
2628 debugmsg( "world '%s' contains no saves", world );
2629 return false;
2630 }
2631
2632 try {
2633 world_generator->set_active_world( wptr );
2634 g->setup();
2635 g->load( wptr->world_saves.front() );
2636 } catch( const std::exception &err ) {
2637 debugmsg( "cannot load world '%s': %s", world, err.what() );
2638 return false;
2639 }
2640
2641 return true;
2642}
std::vector< save_t > world_saves
Definition: worldfactory.h:61

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_core_data()

void game::load_core_data ( loading_ui ui)

Loads core dynamic data.

May throw.

Definition at line 446 of file game.cpp.

447{
448 // core data can be loaded only once and must be first
449 // anyway.
451
453}
void unload_data()
Deletes and unloads all the data previously loaded with load_data_from_path.
Definition: init.cpp:531
std::string jsondir()
Definition: path_info.cpp:230

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

◆ load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path,
const std::string &  src,
loading_ui ui 
)
protected

Loads dynamic data from the given directory.

May throw.

Definition at line 455 of file game.cpp.

456{
458}
void load_data_from_path(const std::string &path, const std::string &src, loading_ui &ui)
Load all data from json files located in the path (recursive).
Definition: init.cpp:460

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm,
bool  pump_events = false 
)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Parameters
pump_eventsIf true, handle window events during loading. If you set this to true, do ensure that the map is not accessed before this function returns (for example, UIs that draw the map should be disabled).

Definition at line 651 of file game.cpp.

652{
653 // TODO: fix point types
654 load_map( tripoint_abs_sm( pos_sm ), pump_events );
655}
void load_map(const tripoint &pos_sm, bool pump_events=false)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:651
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm,
bool  pump_events = false 
)

Definition at line 657 of file game.cpp.

659{
660 m.load( pos_sm, true, pump_events );
661 grid_tracker_ptr->load( m );
662}
void load(const tripoint &w, bool update_vehicles, bool pump_events=false)
Load submaps into grid.
Definition: map.cpp:6622

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2613 of file game.cpp.

2614{
2615 using namespace std::placeholders;
2616 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2617 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2618}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1193
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 917 of file game.cpp.

918{
919 const int radius = HALF_MAPSIZE - 1;
920 // uses submap coordinates
921 std::vector<shared_ptr_fast<npc>> just_added;
922 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
923 const character_id &id = temp->getID();
924 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
925 [id]( const shared_ptr_fast<npc> &n ) {
926 return n->getID() == id;
927 } );
928 if( found != active_npc.end() ) {
929 continue;
930 }
931 if( temp->is_active() ) {
932 continue;
933 }
934 if( temp->has_companion_mission() ) {
935 continue;
936 }
937
938 const tripoint sm_loc = temp->global_sm_location();
939 // NPCs who are out of bounds before placement would be pushed into bounds
940 // This can cause NPCs to teleport around, so we don't want that
941 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
942 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
943 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
944 continue;
945 }
946
947 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
948 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
949 temp->place_on_map();
950 if( !m.inbounds( temp->pos() ) ) {
951 continue;
952 }
953 // In the rare case the npc was marked for death while
954 // it was on the overmap. Kill it.
955 if( temp->marked_for_death ) {
956 temp->die( nullptr );
957 } else {
958 active_npc.push_back( temp );
959 just_added.push_back( temp );
960 }
961 }
962
963 for( const auto &npc : just_added ) {
964 npc->on_load();
965 }
966
967 npcs_dirty = false;
968}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2658
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_packs()

bool game::load_packs ( const std::string &  msg,
const std::vector< mod_id > &  packs,
loading_ui ui 
)

Load content packs.

Parameters
msgstring to display whilst loading prompt
packscontent packs to load in correct dependent order
uistructure for load progress display
Returns
true if all packs were found, false if any were missing

Definition at line 2769 of file game.cpp.

2770{
2771 ui.new_context( msg );
2772 std::vector<mod_id> missing;
2773 std::vector<mod_id> available;
2774
2775 for( const mod_id &e : packs ) {
2776 if( e.is_valid() ) {
2777 available.emplace_back( e );
2778 ui.add_entry( e->name() );
2779 } else {
2780 missing.push_back( e );
2781 }
2782 }
2783
2784 ui.show();
2785 for( const auto &e : available ) {
2786 const MOD_INFORMATION &mod = *e;
2787 load_data_from_dir( mod.path, mod.ident.str(), ui );
2788 ui.proceed();
2789 }
2790
2791 for( const auto &e : missing ) {
2792 debugmsg( "unknown content %s", e.c_str() );
2793 }
2794
2795 return missing.empty();
2796}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 331 of file game.cpp.

332{
333 // UI stuff, not mod-specific per definition
334 inp_mngr.init(); // Load input config JSON
335 // Init mappings for loading the json stuff
337 fullscreen = false;
338 was_fullscreen = false;
339 show_panel_adm = false;
341
342 // These functions do not load stuff from json.
343 // The content they load/initialize is hardcoded into the program.
344 // Therefore they can be loaded here.
345 // If this changes (if they load data from json), they have to
346 // be moved to game::load_mod or game::load_core_data
347
351}
bool was_fullscreen
Definition: game.h:1043
bool fullscreen
Definition: game.h:1042
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2186
void load_global()

References fullscreen, get_auto_pickup(), get_distraction_manager(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, distraction_manager::distraction_manager_gui::load(), auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ load_world_modfiles()

void game::load_world_modfiles ( loading_ui ui)

Loads core data and mods from the active world.

May throw.

Definition at line 2733 of file game.cpp.

2734{
2735 auto &mods = world_generator->active_world->active_mod_order;
2736
2737 // remove any duplicates whilst preserving order (fixes #19385)
2738 std::set<mod_id> found;
2739 mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
2740 if( found.count( e ) ) {
2741 return true;
2742 } else {
2743 found.insert( e );
2744 return false;
2745 }
2746 } ), mods.end() );
2747
2748 // require at least one core mod (saves before version 6 may implicitly require dda pack)
2749 if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
2750 return e->core;
2751} ) ) {
2752 mods.insert( mods.begin(), mod_management::get_default_core_content_pack() );
2753 }
2754
2756 // this code does not care about mod dependencies,
2757 // it assumes that those dependencies are static and
2758 // are resolved during the creation of the world.
2759 // That means world->active_mod_order contains a list
2760 // of mods in the correct order.
2761 load_packs( _( "Loading files" ), mods, ui );
2762
2763 // Load additional mods from that world-specific folder
2764 load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
2765
2767}
void load_artifacts(const std::string &path)
Definition: artifact.cpp:1098
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References world_generator.

Referenced by setup().

◆ look_around() [1/2]

cata::optional< tripoint > game::look_around ( bool  force_3d = false)

Definition at line 6712 of file game.cpp.

6713{
6715 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6716 false, false, tripoint_zero, force_3d );
6717 return result.position;
6718}

References center, look_around(), Character::pos(), tripoint_zero, u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero,
bool  force_3d = false 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6720 of file game.cpp.

6723{
6724 bVMonsterLookFire = false;
6725 // TODO: Make this `true`
6726 const bool allow_zlev_move = m.has_zlevels() && ( get_option<bool>( "FOV_3D" ) || force_3d );
6727
6729
6730 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6731 int &lx = lp.x;
6732 int &ly = lp.y;
6733 int &lz = lp.z;
6734
6735 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6736 bool fast_scroll = false;
6737
6738 std::unique_ptr<ui_adaptor> ui;
6739 catacurses::window w_info;
6740 if( show_window ) {
6741 ui = std::make_unique<ui_adaptor>();
6742 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6743 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6745
6746 // If particularly small, base height on panel width irrespective of other elements.
6747 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6748 if( height < panel_width / 2 ) {
6749 height = panel_width / 2;
6750 }
6751
6752 int la_y = 0;
6753 int la_x = TERMX - panel_width;
6754 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6755 if( position == "left" ) {
6756 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6758 } else {
6759 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6760 }
6761 }
6762 int la_h = height;
6763 int la_w = panel_width;
6764 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6765
6766 ui.position_from_window( w_info );
6767 } );
6768 ui->mark_resize();
6769 }
6770
6771 std::string action;
6772 input_context ctxt( "LOOK" );
6773 ctxt.set_iso( true );
6774 ctxt.register_directions();
6775 ctxt.register_action( "COORDINATE" );
6776 ctxt.register_action( "LEVEL_UP" );
6777 ctxt.register_action( "LEVEL_DOWN" );
6778 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6779 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6780 ctxt.register_action( "SELECT" );
6781 if( peeking ) {
6782 ctxt.register_action( "throw_blind" );
6783 }
6784 if( !select_zone ) {
6785 ctxt.register_action( "TRAVEL_TO" );
6786 ctxt.register_action( "LIST_ITEMS" );
6787 }
6788 ctxt.register_action( "MOUSE_MOVE" );
6789 ctxt.register_action( "CENTER" );
6790
6791 ctxt.register_action( "debug_scent" );
6792 ctxt.register_action( "debug_scent_type" );
6793 ctxt.register_action( "debug_temp" );
6794 ctxt.register_action( "debug_visibility" );
6795 ctxt.register_action( "debug_lighting" );
6796 ctxt.register_action( "debug_radiation" );
6797 ctxt.register_action( "debug_submap_grid" );
6798 ctxt.register_action( "debug_hour_timer" );
6799 ctxt.register_action( "CONFIRM" );
6800 ctxt.register_action( "QUIT" );
6801 ctxt.register_action( "HELP_KEYBINDINGS" );
6802 if( use_tiles ) {
6803 ctxt.register_action( "zoom_out" );
6804 ctxt.register_action( "zoom_in" );
6805 }
6806#if defined(TILES)
6807 ctxt.register_action( "toggle_pixel_minimap" );
6808#endif // TILES
6809
6810 const int old_levz = get_levz();
6811 const int min_levz = force_3d ? -OVERMAP_DEPTH : std::max( old_levz - fov_3d_z_range,
6812 -OVERMAP_DEPTH );
6813 const int max_levz = force_3d ? OVERMAP_HEIGHT : std::min( old_levz + fov_3d_z_range,
6815
6816 m.update_visibility_cache( old_levz );
6818
6819 bool blink = true;
6821
6822 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6823
6824 if( show_window && ui ) {
6825 ui->on_redraw( [&]( const ui_adaptor & ) {
6826 werase( w_info );
6827 draw_border( w_info );
6828
6829 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6830
6831 std::string extended_descr_text = string_format( _( "%s - %s" ),
6832 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6833 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6834 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6835 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6836 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6837#if defined(TILES)
6838 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6839 ctxt.get_desc( "toggle_pixel_minimap" ),
6840 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6841#endif // TILES
6842
6843 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6844 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6845 fast_scroll_text );
6846#if defined(TILES)
6847 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6848 pixel_minimap_text );
6849#endif // TILES
6850
6851 int first_line = 1;
6852 const int last_line = getmaxy( w_info ) - 3;
6853 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6854
6855 wnoutrefresh( w_info );
6856 } );
6857 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6858 draw_look_around_cursor( lp, cache );
6859 } );
6860 add_draw_callback( ter_indicator_cb );
6861 }
6862
6863 cata::optional<tripoint> zone_start;
6864 cata::optional<tripoint> zone_end;
6865 bool zone_blink = false;
6866 bool zone_cursor = true;
6867 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
6868 zone_cursor, is_moving_zone );
6869 add_draw_callback( zone_cb );
6870
6871 is_looking = true;
6872 const tripoint prev_offset = u.view_offset;
6873#if defined(TILES)
6874 const int prev_tileset_zoom = tileset_zoom;
6875 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
6876 get_zoom() != 4 ) {
6877 zoom_out();
6878 }
6880#endif
6881 do {
6882 u.view_offset = center - u.pos();
6883 if( select_zone ) {
6884 if( has_first_point ) {
6885 zone_start = start_point;
6886 zone_end = lp;
6887 } else {
6888 zone_start = lp;
6889 zone_end = cata::nullopt;
6890 }
6891 // Actually accessed from the terrain overlay callback `zone_cb` in the
6892 // call to `ui_manager::redraw`.
6893 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6894 zone_blink = blink;
6895 }
6896
6897 if( is_moving_zone ) {
6898 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
6899 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
6900 // Actually accessed from the terrain overlay callback `zone_cb` in the
6901 // call to `ui_manager::redraw`.
6902 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6903 zone_blink = blink;
6904 }
6907 if( ( select_zone && has_first_point ) || is_moving_zone ) {
6908 ctxt.set_timeout( BLINK_SPEED );
6909 }
6910
6911 //Wait for input
6912 // only specify a timeout here if "EDGE_SCROLL" is enabled
6913 // otherwise use the previously set timeout
6914 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
6915 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
6916 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
6917 if( edge_scrolling ) {
6918 action = ctxt.handle_input( scroll_timeout );
6919 } else {
6920 action = ctxt.handle_input();
6921 }
6922 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
6923 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
6924 blink = true; // Always draw blink symbols when moving cursor
6925 } else if( action == "TIMEOUT" ) {
6926 blink = !blink;
6927 }
6928 if( action == "LIST_ITEMS" ) {
6930 } else if( action == "TOGGLE_FAST_SCROLL" ) {
6931 fast_scroll = !fast_scroll;
6932 } else if( action == "toggle_pixel_minimap" ) {
6934
6935 if( show_window && ui ) {
6936 ui->mark_resize();
6937 }
6938 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
6939 if( !allow_zlev_move ) {
6940 continue;
6941 }
6942
6943 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
6944 lz = clamp( lz + dz, min_levz, max_levz );
6945 center.z = clamp( center.z + dz, min_levz, max_levz );
6946
6947 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
6948 u.view_offset.z = center.z - u.posz();
6950 } else if( action == "TRAVEL_TO" ) {
6951 if( !u.sees( lp ) ) {
6952 add_msg( _( "You can't see that destination." ) );
6953 continue;
6954 }
6955
6956 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
6957 if( route.size() > 1 ) {
6958 route.pop_back();
6959 u.set_destination( route );
6960 } else {
6961 add_msg( m_info, _( "You can't travel there." ) );
6962 continue;
6963 }
6964 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
6966 display_scent();
6967 }
6968 } else if( action == "debug_temp" ) {
6971 }
6972 } else if( action == "debug_lighting" ) {
6975 }
6976 } else if( action == "debug_transparency" ) {
6979 }
6980 } else if( action == "debug_radiation" ) {
6983 }
6984 } else if( action == "debug_submap_grid" ) {
6985 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
6986 } else if( action == "debug_hour_timer" ) {
6988 } else if( action == "EXTENDED_DESCRIPTION" ) {
6990 } else if( action == "CENTER" ) {
6991 center = u.pos();
6992 lp = u.pos();
6993 u.view_offset.z = 0;
6994 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
6995 // This block is structured this way so that edge scroll can work
6996 // whether the mouse is moving at the edge or simply stationary
6997 // at the edge. But even if edge scroll isn't in play, there's
6998 // other things for us to do here.
6999
7000 if( edge_scrolling ) {
7001 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
7002 } else if( action == "MOUSE_MOVE" ) {
7003 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
7004 if( mouse_pos ) {
7005 lx = mouse_pos->x;
7006 ly = mouse_pos->y;
7007 }
7008 }
7009 } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
7010 if( fast_scroll ) {
7011 vec->x *= soffset;
7012 vec->y *= soffset;
7013 }
7014
7015 lx = lx + vec->x;
7016 ly = ly + vec->y;
7017 center.x = center.x + vec->x;
7018 center.y = center.y + vec->y;
7019 } else if( action == "throw_blind" ) {
7020 result.peek_action = PA_BLIND_THROW;
7021 } else if( action == "zoom_in" ) {
7022 center.x = lp.x;
7023 center.y = lp.y;
7024 zoom_in();
7026 } else if( action == "zoom_out" ) {
7027 center.x = lp.x;
7028 center.y = lp.y;
7029 zoom_out();
7031 }
7032 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
7033 action != "throw_blind" );
7034
7035 if( m.has_zlevels() && center.z != old_levz ) {
7036 m.invalidate_map_cache( old_levz );
7037 m.build_map_cache( old_levz );
7038 u.view_offset.z = 0;
7039 }
7040
7041 ctxt.reset_timeout();
7042 u.view_offset = prev_offset;
7043 zone_cb = nullptr;
7044 is_looking = false;
7045
7047 bVMonsterLookFire = true;
7048
7049 if( action == "CONFIRM" || action == "SELECT" ) {
7050 result.position = is_moving_zone ? zone_start : lp;
7051 }
7052
7053#if defined(TILES)
7054 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
7055 // Reset the tileset zoom to the previous value
7056 set_zoom( prev_tileset_zoom );
7058 }
7059#endif
7060
7061 return result;
7062}
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2191
void set_zoom(int level)
Definition: game.cpp:7219
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5823
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6699
int get_zoom() const
Definition: game.cpp:7231
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5657
void invalidate_map_cache(const int zlev)
Definition: map.h:470
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2154
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const cata::optional< tripoint > &zone_start, const cata::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3190
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int BLINK_SPEED
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

cata::optional< tripoint > game::look_debug ( )

Definition at line 5816 of file game.cpp.

5817{
5818 editmap edit;
5819 return edit.edit();
5820}
cata::optional< tripoint > edit()
Definition: editmap.cpp:339

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 3147 of file game.cpp.

3148{
3150 if( ui ) {
3151 ui->mark_resize();
3152 }
3153}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 2889 of file game.cpp.

2890{
2891 return *memorial_logger_ptr;
2892}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 3838 of file game.cpp.

3839{
3840 const monster_visible_info &mon_visible = u.get_mon_visible();
3841 const auto &unique_types = mon_visible.unique_types;
3842 const auto &unique_mons = mon_visible.unique_mons;
3843 const auto &dangerous = mon_visible.dangerous;
3844
3845 const int width = getmaxx( w ) - 2 * hor_padding;
3846 const int maxheight = getmaxy( w );
3847
3848 const int startrow = 0;
3849
3850 // Print the direction headings
3851 // Reminder:
3852 // 7 0 1 unique_types uses these indices;
3853 // 6 8 2 0-7 are provide by direction_from()
3854 // 5 4 3 8 is used for local monsters (for when we explain them below)
3855
3856 const std::array<std::string, 8> dir_labels = {{
3857 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
3858 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
3859 }
3860 };
3861 std::array<int, 8> widths;
3862 for( int i = 0; i < 8; i++ ) {
3863 widths[i] = utf8_width( dir_labels[i] );
3864 }
3865 std::array<int, 8> xcoords;
3866 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
3867 xcoords[0] = xcoords[4] = width / 3;
3868 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
3869 xcoords[5] = xcoords[6] = xcoords[7] = 0;
3870 //for the alignment of the 1,2,3 rows on the right edge
3871 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
3872 for( int i = 0; i < 8; i++ ) {
3873 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
3874 : ( dangerous[i] ? c_light_red : c_light_gray );
3875 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
3876 }
3877
3878 // Print the symbols of all monsters in all directions.
3879 for( int i = 0; i < 8; i++ ) {
3880 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
3881
3882 // The list of symbols needs a space on each end.
3883 int symroom = ( width / 3 ) - widths[i] - 2;
3884 const int typeshere_npc = unique_types[i].size();
3885 const int typeshere_mon = unique_mons[i].size();
3886 const int typeshere = typeshere_mon + typeshere_npc;
3887 for( int j = 0; j < typeshere && j < symroom; j++ ) {
3888 nc_color c;
3889 std::string sym;
3890 if( symroom < typeshere && j == symroom - 1 ) {
3891 // We've run out of room!
3892 c = c_white;
3893 sym = "+";
3894 } else if( j < typeshere_npc ) {
3895 switch( unique_types[i][j]->get_attitude() ) {
3896 case NPCATT_KILL:
3897 c = c_red;
3898 break;
3899 case NPCATT_FOLLOW:
3900 c = c_light_green;
3901 break;
3902 default:
3903 c = c_pink;
3904 break;
3905 }
3906 sym = "@";
3907 } else {
3908 const mtype &mt = *unique_mons[i][j - typeshere_npc].first;
3909 c = mt.color;
3910 sym = mt.sym;
3911 }
3912 mvwprintz( w, pr, c, sym );
3913
3914 pr.x++;
3915 }
3916 }
3917
3918 // Now we print their full names!
3919 struct nearest_loc_and_cnt {
3920 int nearest_loc;
3921 int cnt;
3922 };
3923 std::map<const mtype *, nearest_loc_and_cnt> all_mons;
3924 for( int loc = 0; loc < 9; loc++ ) {
3925 for( const std::pair<const mtype *, int> &mon : unique_mons[loc] ) {
3926 const auto mon_it = all_mons.find( mon.first );
3927 if( mon_it == all_mons.end() ) {
3928 all_mons.emplace( mon.first, nearest_loc_and_cnt{ loc, mon.second } );
3929 } else {
3930 // 8 being the nearest location (local monsters)
3931 mon_it->second.nearest_loc = std::max( mon_it->second.nearest_loc, loc );
3932 mon_it->second.cnt += mon.second;
3933 }
3934 }
3935 }
3936 std::vector<std::pair<const mtype *, int>> mons_at[9];
3937 for( const std::pair<const mtype *const, nearest_loc_and_cnt> &mon : all_mons ) {
3938 mons_at[mon.second.nearest_loc].emplace_back( mon.first, mon.second.cnt );
3939 }
3940
3941 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
3942 // is blank.
3943 point pr( hor_padding, 4 + startrow );
3944
3945 // Print monster names, starting with those at location 8 (nearby).
3946 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
3947 // Separate names by some number of spaces (more for local monsters).
3948 int namesep = ( j == 8 ? 2 : 1 );
3949 for( const std::pair<const mtype *, int> &mon : mons_at[j] ) {
3950 const mtype *const type = mon.first;
3951 const int count = mon.second;
3952 if( pr.y >= maxheight ) {
3953 // no space to print to anyway
3954 break;
3955 }
3956
3957 const mtype &mt = *type;
3958 std::string name = mt.nname( count );
3959 // Some languages don't have plural forms, but we want to always
3960 // omit 1.
3961 if( count != 1 ) {
3962 name = string_format( pgettext( "monster count and name", "%1$d %2$s" ),
3963 count, name );
3964 }
3965
3966 // Move to the next row if necessary. (The +2 is for the "Z ").
3967 if( pr.x + 2 + utf8_width( name ) >= width ) {
3968 pr.y++;
3969 pr.x = hor_padding;
3970 }
3971
3972 if( pr.y < maxheight ) { // Don't print if we've overflowed
3973 mvwprintz( w, pr, mt.color, mt.sym );
3974 pr.x += 2; // symbol and space
3975 nc_color danger = c_dark_gray;
3976 if( mt.difficulty >= 30 ) {
3977 danger = c_red;
3978 } else if( mt.difficulty >= 16 ) {
3979 danger = c_light_red;
3980 } else if( mt.difficulty >= 8 ) {
3981 danger = c_white;
3982 } else if( mt.agro > 0 ) {
3983 danger = c_light_gray;
3984 }
3985 mvwprintz( w, pr, danger, name );
3986 pr.x += utf8_width( name ) + namesep;
3987 }
3988 }
3989 }
3990}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< std::pair< const mtype *, int > > unique_mons[9]
Definition: avatar.h:48
bool dangerous[8]
Definition: avatar.h:51
std::vector< npc * > unique_types[9]
Definition: avatar.h:47
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:256
nc_color color
Definition: mtype.h:261
int difficulty
Definition: mtype.h:267
int agro
e.g.
Definition: mtype.h:272

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, detail::count(), monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, pgettext(), string_format(), mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 3992 of file game.cpp.

3993{
3994 int newseen = 0;
3995 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
3996 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
3997 safe_proxy_dist;
3998
3999 monster_visible_info &mon_visible = u.get_mon_visible();
4000 auto &new_seen_mon = mon_visible.new_seen_mon;
4001 auto &unique_types = mon_visible.unique_types;
4002 auto &unique_mons = mon_visible.unique_mons;
4003 auto &dangerous = mon_visible.dangerous;
4004
4005 // 7 0 1 unique_types uses these indices;
4006 // 6 8 2 0-7 are provide by direction_from()
4007 // 5 4 3 8 is used for local monsters (for when we explain them below)
4008 for( auto &t : unique_types ) {
4009 t.clear();
4010 }
4011 for( auto &m : unique_mons ) {
4012 m.clear();
4013 }
4014 std::fill( dangerous, dangerous + 8, false );
4015
4016 const tripoint view = u.pos() + u.view_offset;
4017 new_seen_mon.clear();
4018
4019 // TODO: no reason to have it static here
4020 static time_point previous_turn = calendar::start_of_cataclysm;
4021 const time_duration sm_ignored_time = time_duration::from_turns(
4022 get_option<int>( "SAFEMODEIGNORETURNS" ) );
4023
4025 monster *m = dynamic_cast<monster *>( c );
4026 npc *p = dynamic_cast<npc *>( c );
4027 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
4028 const int mx = POSX + ( c->posx() - view.x );
4029 const int my = POSY + ( c->posy() - view.y );
4030 int index = 8;
4031 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
4032 // for compatibility with old code, see diagram below, it explains the values for index,
4033 // also might need revisiting one z-levels are in.
4034 switch( dir_to_mon ) {
4038 index = 7;
4039 break;
4041 case direction::NORTH:
4043 index = 0;
4044 break;
4048 index = 1;
4049 break;
4051 case direction::WEST:
4053 index = 6;
4054 break;
4056 case direction::CENTER:
4058 index = 8;
4059 break;
4061 case direction::EAST:
4063 index = 2;
4064 break;
4068 index = 5;
4069 break;
4071 case direction::SOUTH:
4073 index = 4;
4074 break;
4078 index = 3;
4079 break;
4080 }
4081 }
4082
4083 rule_state safemode_state = RULE_NONE;
4084 const bool safemode_empty = get_safemode().empty();
4085
4086 if( m != nullptr ) {
4087 //Safemode monster check
4088 monster &critter = *m;
4089
4090 const monster_attitude matt = critter.attitude( &u );
4091 const int mon_dist = rl_dist( u.pos(), critter.pos() );
4092 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
4093
4094 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4095 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
4096 if( index < 8 && critter.sees( g->u ) ) {
4097 dangerous[index] = true;
4098 }
4099
4100 if( !safemode_empty || mon_dist <= iProxyDist ) {
4101 bool passmon = false;
4102 if( critter.ignoring > 0 ) {
4103 if( safe_mode != SAFE_MODE_ON ) {
4104 critter.ignoring = 0;
4105 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
4106 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
4107 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
4108 passmon = true;
4109 }
4110 critter.lastseen_turn = calendar::turn;
4111 }
4112
4113 if( !passmon ) {
4114 newseen++;
4115 new_seen_mon.push_back( shared_from( critter ) );
4116 }
4117 }
4118 }
4119
4120 std::vector<std::pair<const mtype *, int>> &vec = unique_mons[index];
4121 const auto mon_it = std::find_if( vec.begin(), vec.end(),
4122 [&]( const std::pair<const mtype *, int> &elem ) {
4123 return elem.first == critter.type;
4124 } );
4125 if( mon_it == vec.end() ) {
4126 vec.emplace_back( critter.type, 1 );
4127 } else {
4128 mon_it->second++;
4129 }
4130 } else if( p != nullptr ) {
4131 //Safe mode NPC check
4132
4133 const int npc_dist = rl_dist( u.pos(), p->pos() );
4134 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
4135 npc_dist );
4136
4137 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4138 p->get_attitude() == NPCATT_KILL ) ) {
4139 if( !safemode_empty || npc_dist <= iProxyDist ) {
4140 newseen++;
4141 }
4142 }
4143 unique_types[index].push_back( p );
4144 }
4145 }
4146
4147 if( newseen > mostseen ) {
4148 if( newseen - mostseen == 1 ) {
4149 if( !new_seen_mon.empty() ) {
4150 monster &critter = *new_seen_mon.back();
4152 string_format( _( "%s spotted!" ), critter.name() ) );
4153 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
4154 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
4156 u.add_effect( effect_adrenaline_mycus, 30_minutes );
4157 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
4158 // Triffids present. We ain't got TIME to adrenaline comedown!
4159 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4160 u.mod_pain( 3 ); // Does take it out of you, though
4161 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4162 }
4163 }
4164 } else {
4165 //Hostile NPC
4167 _( "Hostile survivor spotted!" ) );
4168 }
4169 } else {
4171 }
4173 if( safe_mode == SAFE_MODE_ON ) {
4175 }
4176 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4177 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4178 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4179 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4181 add_msg( m_info, _( "Safe mode ON!" ) );
4182 }
4183 }
4184
4185 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4187 }
4188
4189 previous_turn = calendar::turn;
4190 mostseen = newseen;
4191}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1250
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:202
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1812
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1086
cata::optional< time_point > lastseen_turn
Definition: monster.h:509
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2077
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
bool is_valid_in_w_terrain(const point &p)
Definition: game.cpp:281
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:55
@ MATT_FOLLOW
Definition: monster.h:61
@ MATT_ATTACK
Definition: monster.h:62
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4228 of file game.cpp.

4229{
4230 cleanup_dead();
4231
4232 for( monster &critter : all_monsters() ) {
4233 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4234 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4235 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4236 critter.pos().to_string(), m.tername( critter.pos() ) );
4237 dbg( DL::Error ) << msg;
4238 add_msg( m_debug, msg );
4239 bool okay = false;
4240 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4241 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4242 critter.setpos( dest );
4243 okay = true;
4244 break;
4245 }
4246 }
4247 if( !okay ) {
4248 // die of "natural" cause (overpopulation is natural)
4249 critter.die( nullptr );
4250 }
4251 }
4252
4253 if( !critter.is_dead() ) {
4254 critter.process_items();
4255 }
4256
4257 if( !critter.is_dead() ) {
4258 critter.process_turn();
4259 }
4260
4261 m.creature_in_field( critter );
4262 if( calendar::once_every( 1_days ) ) {
4263 if( critter.has_flag( MF_MILKABLE ) ) {
4264 critter.refill_udders();
4265 }
4266 critter.try_reproduce();
4267 }
4268 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4269 critter.made_footstep = false;
4270 // Controlled critters don't make their own plans
4271 if( !critter.has_effect( effect_ai_controlled ) ) {
4272 // Formulate a path to follow
4273 critter.plan();
4274 }
4275 critter.move(); // Move one square, possibly hit u
4276 critter.process_triggers();
4277 m.creature_in_field( critter );
4278 }
4279
4280 if( !critter.is_dead() &&
4281 u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
4282 u.get_power_level() >= 25_kJ &&
4283 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4284 !critter.is_hallucination() ) {
4285 u.mod_power_level( -25_kJ );
4286 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4288 _( "Your motion alarm goes off!" ) );
4289 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4290 u.wake_up();
4291 }
4292 }
4293 }
4294
4295 cleanup_dead();
4296
4297 // The remaining monsters are all alive, but may be outside of the reality bubble.
4298 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4299 // monster::die function is not called.
4300 for( monster &critter : all_monsters() ) {
4301 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4302 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4303 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4304 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4305 despawn_monster( critter );
4306 }
4307 }
4308
4309 // Now, do active NPCs.
4310 for( npc &guy : g->all_npcs() ) {
4311 int turns = 0;
4312 if( guy.is_mounted() ) {
4313 guy.check_mount_is_spooked();
4314 }
4315 m.creature_in_field( guy );
4316 if( !guy.has_effect( effect_npc_suspend ) ) {
4317 guy.process_turn();
4318 }
4319 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4320 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4321 ) {
4322 int moves = guy.moves;
4323 guy.move();
4324 if( moves == guy.moves ) {
4325 // Count every time we exit npc::move() without spending any moves.
4326 turns++;
4327 }
4328
4329 // Turn on debug mode when in infinite loop
4330 // It has to be done before the last turn, otherwise
4331 // there will be no meaningful debug output.
4332 if( turns == 9 ) {
4333 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4334 guy.name );
4335 debug_mode = true;
4336 }
4337 }
4338
4339 // If we spun too long trying to decide what to do (without spending moves),
4340 // Invoke cognitive suspension to prevent an infinite loop.
4341 if( turns == 10 ) {
4342 add_msg( _( "%s faints!" ), guy.name );
4343 guy.reboot();
4344 }
4345
4346 if( !guy.is_dead() ) {
4347 guy.npc_update_body();
4348 }
4349 }
4350 cleanup_dead();
4351}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1987
units::energy get_power_level() const
Definition: character.cpp:1967
void wake_up()
Definition: avatar.cpp:957
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), alert, all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2138 of file game.cpp.

2140{
2141 const int rate = get_option<int>( "EDGE_SCROLL" );
2142 auto ret = std::make_pair( tripoint_zero, last );
2143 if( rate == -1 ) {
2144 // Fast return when the option is disabled.
2145 return ret;
2146 }
2147 // Ensure the parameters are used even if the #if below is false
2148 ( void ) ctxt;
2149 ( void ) speed;
2150 ( void ) iso;
2151#if (defined TILES || defined _WIN32 || defined WINDOWS)
2152 auto now = std::chrono::steady_clock::now();
2153 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2154 return ret;
2155 } else {
2157 }
2158 const input_event event = ctxt.get_raw_input();
2159 if( event.type == CATA_INPUT_MOUSE ) {
2160 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2161 if( event.mouse_pos.x <= threshold.x ) {
2162 ret.first.x -= speed;
2163 if( iso ) {
2164 ret.first.y -= speed;
2165 }
2166 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2167 ret.first.x += speed;
2168 if( iso ) {
2169 ret.first.y += speed;
2170 }
2171 }
2172 if( event.mouse_pos.y <= threshold.y ) {
2173 ret.first.y -= speed;
2174 if( iso ) {
2175 ret.first.x += speed;
2176 }
2177 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2178 ret.first.y += speed;
2179 if( iso ) {
2180 ret.first.x -= speed;
2181 }
2182 }
2183 ret.second = ret.first;
2184 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2185 ret.first = ret.second;
2186 }
2187#endif
2188 return ret;
2189}
@ CATA_INPUT_TIMEOUT
Definition: input.h:81
@ CATA_INPUT_MOUSE
Definition: input.h:84

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2200 of file game.cpp.

2201{
2202 // overmap has no iso mode
2206 return ret.first;
2207}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2138
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1095
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1096

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2191 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2575 of file game.cpp.

2576{
2577 const std::string save_dir = get_world_base_save_path();
2578 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2579 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2580 const std::string prefix = base64_encode( u.name ) + ".";
2581
2582 if( !assure_dir_exist( graveyard_dir ) ) {
2583 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2584 }
2585
2586 if( !assure_dir_exist( graveyard_save_dir ) ) {
2587 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2588 }
2589
2590 const auto save_files = get_files_from_path( prefix, save_dir );
2591 if( save_files.empty() ) {
2592 debugmsg( "could not find save files in '%s'", save_dir );
2593 }
2594
2595 for( const auto &src_path : save_files ) {
2596 const std::string dst_path = graveyard_save_dir +
2597 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2598
2599 if( rename_file( src_path, dst_path ) ) {
2600 continue;
2601 }
2602
2603 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2604
2605 if( remove_file( src_path ) ) {
2606 continue;
2607 }
2608
2609 debugmsg( "could not remove file '%s'", src_path );
2610 }
2611}
@ prefix
Definition: enums.h:79
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:362
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5284 of file game.cpp.

5285{
5286 const optional_vpart_position vp = m.veh_at( u.pos() );
5287 if( !vp ) {
5288 debugmsg( "Tried to exit non-existent vehicle." );
5289 return;
5290 }
5291 vehicle *const veh = &vp->vehicle();
5292 if( u.pos() == dest_loc ) {
5293 debugmsg( "Need somewhere to dismount towards." );
5294 return;
5295 }
5296 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5297 // TODO:: make dir() const correct!
5298 const units::angle d = ray.dir();
5299 add_msg( _( "You dive from the %s." ), veh->name );
5300 m.unboard_vehicle( u.pos() );
5301 u.moves -= 200;
5302 // Dive three tiles in the direction of tox and toy
5303 fling_creature( &u, d, 30, true );
5304 // Hit the ground according to vehicle speed
5305 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5306 if( veh->velocity > 0 ) {
5307 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5308 } else {
5309 fling_creature( &u, veh->face.dir() + 180_degrees,
5310 -( veh->velocity ) / static_cast<float>( 100 ) );
5311 }
5312 }
5313}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
Flings the input creature in the given direction.
Definition: game.cpp:9892

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3657 of file game.cpp.

3658{
3659 // ignore while underground or above limits
3660 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3661 return LIGHT_AMBIENT_MINIMAL;
3662 }
3663
3664 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3665 // Already found the light level for now?
3666 return latest_lightlevels[zlev];
3667 }
3668
3669 float ret = LIGHT_AMBIENT_MINIMAL;
3670
3671 // Sunlight/moonlight related stuff
3673 if( !weather.lightning_active ) {
3675 } else {
3676 // Recent lightning strike has lit the area
3678 }
3679
3681
3682 // Artifact light level changes here. Even though some of these only have an effect
3683 // aboveground it is cheaper performance wise to simply iterate through the entire
3684 // list once instead of twice.
3685 float mod_ret = -1;
3686 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3687 // will trump a lower one.
3688 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3689 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3690 const time_duration left = e->when - calendar::turn;
3691 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3692 if( left > 25_turns ) {
3693 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3694 // and the last 25 scale back towards normal.
3695 } else {
3696 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3697 }
3698 }
3700 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3701 mod_ret = std::max<float>( ret, default_daylight_level() );
3702 }
3703 // If we had a changed light level due to an artifact event then it overwrites
3704 // the natural light level.
3705 if( mod_ret > -1 ) {
3706 ret = mod_ret;
3707 }
3708
3709 // Cap everything to our minimum light level
3710 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3711
3712 latest_lightlevels[zlev] = ret;
3713
3714 return ret;
3715}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1068
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5415 of file game.cpp.

5416{
5417 enum choices : int {
5418 talk = 0,
5419 swap_pos,
5420 push,
5421 examine_wounds,
5422 use_item,
5423 sort_armor,
5424 attack,
5425 disarm,
5426 steal
5427 };
5428
5429 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5430
5431 uilist amenu;
5432
5433 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5434 amenu.addentry( talk, true, 't', _( "Talk" ) );
5435 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5436 !u.is_mounted(), 's', _( "Swap positions" ) );
5437 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5438 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5439 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5440 amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
5441 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5442 if( !who.is_player_ally() ) {
5443 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5444 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5445 }
5446
5447 amenu.query();
5448
5449 const int choice = amenu.ret;
5450 if( choice == talk ) {
5451 who.talk_to_u();
5452 } else if( choice == swap_pos ) {
5453 if( !prompt_dangerous_tile( who.pos() ) ) {
5454 return true;
5455 }
5456 // TODO: Make NPCs protest when displaced onto dangerous crap
5457 add_msg( _( "You swap places with %s." ), who.name );
5458 swap_critters( u, who );
5459 // TODO: Make that depend on stuff
5460 u.mod_moves( -200 );
5461 } else if( choice == push ) {
5462 // TODO: Make NPCs protest when displaced onto dangerous crap
5463 tripoint oldpos = who.pos();
5464 who.move_away_from( u.pos(), true );
5465 u.mod_moves( -20 );
5466 if( oldpos != who.pos() ) {
5467 add_msg( _( "%s moves out of the way." ), who.name );
5468 } else {
5469 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5470 }
5471 } else if( choice == examine_wounds ) {
5472 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5473
5474 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5475 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5476 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5477 0.0f, 0.0f );
5478 } else if( choice == use_item ) {
5479 static const std::string heal_string( "heal" );
5480 const auto will_accept = []( const item & it ) {
5481 const auto use_fun = it.get_use( heal_string );
5482 if( use_fun == nullptr ) {
5483 return false;
5484 }
5485
5486 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5487
5488 return actor != nullptr &&
5489 actor->limb_power >= 0 &&
5490 actor->head_power >= 0 &&
5491 actor->torso_power >= 0;
5492 };
5493 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5494
5495 if( !loc ) {
5496 add_msg( _( "Never mind" ) );
5497 return false;
5498 }
5499 item &used = *loc;
5500 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5501 if( did_use ) {
5502 // Note: exiting a body part selection menu counts as use here
5503 u.mod_moves( -300 );
5504 }
5505 } else if( choice == sort_armor ) {
5506 who.sort_armor();
5507 u.mod_moves( -100 );
5508 } else if( choice == attack ) {
5509 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5510 u.melee_attack( who, true );
5511 who.on_attacked( u );
5512 }
5513 } else if( choice == disarm ) {
5514 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5515 u.disarm( who );
5516 }
5517 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5518 u.steal( who );
5519 }
5520
5521 return true;
5522}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5848
bool in_sleep_state() const override
Definition: character.cpp:9325
void melee_attack(Creature &t, bool allow_special, const matec_id &force_technique, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:390
int per_cur
Definition: character.h:250
void steal(npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2391
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8832
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:4909
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1011
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:731
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1449
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2535
void disarm(npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2315
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:604

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 4854 of file game.cpp.

4855{
4856 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
4857}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 9850 of file game.cpp.

9851{
9852 // TODO: Move this to a character method
9853 if( !u.is_mounted() ) {
9854 const item muscle( "muscle" );
9855 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
9856 if( u.has_active_bionic( bid ) ) {// active power gen
9857 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
9858 } else if( u.has_bionic( bid ) ) {// passive power gen
9859 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
9860 }
9861 }
9862
9863 if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
9864 if( u.movement_mode_is( CMM_RUN ) ) {
9865 u.mod_power_level( -55_J );
9866 } else {
9867 u.mod_power_level( -35_J );
9868 }
9869 }
9870 }
9871
9872 if( u.movement_mode_is( CMM_RUN ) ) {
9873 if( !u.can_run() ) {
9875 }
9876 }
9877
9878 // apply martial art move bonuses
9879 u.martial_arts_data->ma_onmove_effects( u );
9880
9882}
@ CMM_RUN
Definition: character.h:103
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1329
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1619
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1928
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1877
void do_ambient()
Definition: sounds.cpp:1616
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 9884 of file game.cpp.

9885{
9886#if defined(TILES)
9887 tilecontext->on_options_changed();
9888#endif
9889 grid_tracker_ptr->on_options_changed();
9890}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1490 of file handle_action.cpp.

1491{
1492 uilist as_m;
1493
1494 as_m.text = _( "What do you want to consume?" );
1495
1496 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1497 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1498 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1499 as_m.query();
1500
1501 switch( as_m.ret ) {
1502 case 0:
1504 break;
1505 case 1:
1507 break;
1508 case 2:
1510 break;
1511 default:
1512 break;
1513 }
1514}
std::vector< uilist_entry > entries
Definition: ui.h:323
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4353 of file game.cpp.

4354{
4355 std::vector<npc *> travelling_npcs;
4356 static constexpr int move_search_radius = 600;
4357 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4358 if( !elem ) {
4359 continue;
4360 }
4361 npc *npc_to_add = elem.get();
4362 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4363 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4364 travelling_npcs.push_back( npc_to_add );
4365 }
4366 }
4367 for( auto &elem : travelling_npcs ) {
4368 if( elem->has_omt_destination() ) {
4369 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4370 //recalculate path, we got distracted doing something else probably
4371 elem->omt_path.clear();
4372 }
4373 if( elem->omt_path.empty() ) {
4374 const tripoint_abs_omt &from = elem->global_omt_location();
4375 const tripoint_abs_omt &to = elem->goal;
4376 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4378 if( elem->omt_path.empty() ) {
4379 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4380 elem->get_name(), from.to_string(), to.to_string() );
4381 elem->goal = npc::no_goal_point;
4382 elem->mission = NPC_MISSION_NULL;
4383 }
4384 } else {
4385 if( elem->omt_path.back() == elem->global_omt_location() ) {
4386 elem->omt_path.pop_back();
4387 }
4388 // TODO: fix point types
4389 elem->travel_overmap(
4390 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4391 }
4392 reload_npcs();
4393 }
4394 }
4395 return;
4396}
std::vector< tripoint_abs_omt > omt_path
Definition: character.h:970
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1338
bool is_active() const
Definition: npc.cpp:2195
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:179
@ NPC_MISSION_TRAVELLING
Definition: npc.h:191
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5774 of file game.cpp.

5775{
5776 const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5777 if( !p ) {
5778 return;
5779 }
5780
5781 if( p->z != 0 ) {
5782 const tripoint old_pos = u.pos();
5783 vertical_move( p->z, false, true );
5784
5785 if( old_pos != u.pos() ) {
5786 look_around();
5787 vertical_move( p->z * -1, false, true );
5788 }
5789 return;
5790 }
5791
5792 if( m.impassable( u.pos() + *p ) || m.obstructed_by_vehicle_rotation( u.pos(), u.pos() + *p ) ) {
5793 return;
5794 }
5795
5796 peek( u.pos() + *p );
5797}
cata::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:984

References _, choose_direction(), map::impassable(), look_around(), m, map::obstructed_by_vehicle_rotation(), peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5799 of file game.cpp.

5800{
5801 u.moves -= 200;
5802 tripoint prev = u.pos();
5803 u.setpos( p );
5804 tripoint center = p;
5805 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5806 true );
5807 u.setpos( prev );
5808
5809 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5810 item_location loc;
5811 avatar_action::plthrow( u, loc, p );
5812 }
5814}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11181 of file game.cpp.

11182{
11183 if( !calendar::once_every( 1_hours ) ) {
11184 return;
11185 }
11186 // Create a new NPC?
11187 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11188 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11189 return;
11190 }
11191
11192 float density = get_option<float>( "NPC_DENSITY" );
11193 static constexpr int density_search_radius = 60;
11194 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11195 if( npc_num > 0.0 ) {
11196 // 100%, 80%, 64%, 52%, 41%, 33%...
11197 density *= std::pow( 0.8f, npc_num );
11198 }
11199
11200 if( !x_in_y( density, 100 ) ) {
11201 return;
11202 }
11203 bool spawn_allowed = false;
11205 int counter = 0;
11206 while( !spawn_allowed ) {
11207 if( counter >= 10 ) {
11208 return;
11209 }
11210 static constexpr int radius_spawn_range = 120;
11211 const tripoint_abs_omt u_omt = u.global_omt_location();
11212 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11213 rng( -radius_spawn_range, radius_spawn_range ) );
11214 spawn_point.z() = 0;
11215 const oter_id oter = overmap_buffer.ter( spawn_point );
11216 // shouldn't spawn on lakes or rivers.
11217 if( !is_river_or_lake( oter ) ) {
11218 spawn_allowed = true;
11219 }
11220 counter += 1;
11221 }
11222 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11223 tmp->normalize();
11224 tmp->randomize();
11225 std::string new_fac_id = "solo_";
11226 new_fac_id += tmp->name;
11227 // create a new "lone wolf" faction for this one NPC
11228 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11229 faction_id( "no_faction" ) );
11230 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11231 // adds the npc to the correct overmap.
11232 // Only spawn random NPCs on z-level 0
11233 // TODO: fix point types
11234 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11235 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11237 tmp->form_opinion( u );
11238 tmp->mission = NPC_MISSION_NULL;
11239 tmp->long_term_goal_action();
11240 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11241 tmp->getID() ) );
11242 // This will make the new NPC active- if its nearby to the player
11243 load_npcs();
11244}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(const point &p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:563

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 9582 of file game.cpp.

9583{
9584 if( dest_loc.z != u.posz() && !via_ramp ) {
9585 // No vertical phasing yet
9586 return false;
9587 }
9588
9589 //probability travel through walls but not water
9590 tripoint dest = dest_loc;
9591 // tile is impassable
9592 int tunneldist = 0;
9593 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
9594 while( m.impassable( dest ) ||
9595 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
9596 //add 1 to tunnel distance for each impassable tile in the line
9597 tunneldist += 1;
9598 //Being dimensionally anchored prevents quantum shenanigans.
9599 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
9601 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
9602 return false;
9603 }
9604
9605 if( tunneldist > 24 ) {
9606 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
9607 return false;
9608 }
9609
9610 dest.x += d.x;
9611 dest.y += d.y;
9612 }
9613
9614 if( tunneldist != 0 ) {
9615 if( ( tunneldist - 1 ) * 100_kJ
9616 > //The first 100 was already taken up by the bionic's activation cost.
9617 u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
9618 if( tunneldist * 100_kJ >
9620 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
9621 } else {
9622 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %i bionic power to travel that thickness of material." ),
9623 ( 100 * tunneldist ) );
9624 }
9625 return false;
9626 }
9627
9628 if( u.in_vehicle ) {
9629 m.unboard_vehicle( u.pos() );
9630 }
9631
9632 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
9633 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
9634 u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
9635 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
9636 u.moves -= ( 50 + ( tunneldist * 50 ) );
9637 u.setpos( dest );
9638
9639 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
9640 m.board_vehicle( u.pos(), &u );
9641 }
9642
9643 u.grab( OBJECT_NONE );
9645 m.creature_on_trap( u );
9646 return true;
9647 }
9648
9649 return false;
9650}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3270
units::energy get_max_power_level() const
Definition: character.cpp:1972
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1201
void on_move_effects()
Definition: game.cpp:9850
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1049
constexpr int sgn(const T x)
Definition: enums.h:8

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5745 of file game.cpp.

5746{
5747 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5748 _( "There is nothing to pick up nearby." ),
5749 ACTION_PICKUP, false );
5750 if( !examp_ ) {
5751 return;
5752 }
5753 pickup( *examp_ );
5754}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5756 of file game.cpp.

5757{
5758 // Highlight target
5759 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5760 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5761 } );
5762 add_draw_callback( hilite_cb );
5763
5764 pickup::pick_up( p, 0 );
5765}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5767 of file game.cpp.

5768{
5769 pickup::pick_up( u.pos(), 1 );
5770}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4802 of file game.cpp.

4803{
4804 // TODO: change this into an assert, it must never happen.
4805 if( id.is_null() ) {
4806 return nullptr;
4807 }
4808 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4809}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4802

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4811 of file game.cpp.

4815{
4817 if( forced || can_place_monster( *mon, center ) ) {
4818 where = center;
4819 }
4820
4821 // This loop ensures the monster is placed as close to the center as possible,
4822 // but all places that equally far from the center have the same probability.
4823 for( int r = 1; r <= radius && !where; ++r ) {
4825 }
4826
4827 if( !where ) {
4828 return nullptr;
4829 }
4830 mon->spawn( *where );
4831 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4832}
static cata::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4784
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4768

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4792 of file game.cpp.

4793{
4794 return place_critter_around( id, p, 0 );
4795}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4797 of file game.cpp.

4798{
4799 return place_critter_around( mon, p, 0 );
4800}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 4834 of file game.cpp.

4835{
4836 // TODO: change this into an assert, it must never happen.
4837 if( id.is_null() ) {
4838 return nullptr;
4839 }
4840 return place_critter_within( make_shared_fast<monster>( id ), range );
4841}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:4834

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 4843 of file game.cpp.

4845{
4846 const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
4847 if( !where ) {
4848 return nullptr;
4849 }
4850 mon->spawn( *where );
4851 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4852}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9220 of file game.cpp.

9221{
9222 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9223 if( const cata::optional<std::string> label = vp1.get_label() ) {
9224 add_msg( m_info, _( "Label here: %s" ), *label );
9225 }
9226 std::string signage = m.get_signage( dest_loc );
9227 if( !signage.empty() ) {
9228 if( !u.has_trait( trait_ILLITERATE ) ) {
9229 add_msg( m_info, _( "The sign says: %s" ), signage );
9230 } else {
9231 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9232 }
9233 }
9234 if( m.has_graffiti_at( dest_loc ) ) {
9235 if( !u.has_trait( trait_ILLITERATE ) ) {
9236 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9237 } else {
9238 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9239 }
9240 }
9241 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9242 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9243 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9244 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9245 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9246 dest_loc ) );
9247 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9248 }
9249 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9250 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9251 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9252 dest_loc ) );
9253 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9254 }
9255 }
9256 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9257 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9258 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9259 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9260 if( u.is_mounted() ) {
9261 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9262 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9263 } else {
9264 const bodypart_id bp = u.get_random_body_part();
9265 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9266 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9267 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9268 body_part_name_accusative( bp->token ),
9269 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9270 dest_loc ) );
9271 }
9272 }
9273 }
9274 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9275 u.add_effect( effect_bouldering, 1_turns, num_bp );
9276 } else if( u.has_effect( effect_bouldering ) ) {
9278 }
9279 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9280 u.add_effect( effect_no_sight, 1_turns, num_bp );
9281 } else if( u.has_effect( effect_no_sight ) ) {
9283 }
9284
9285 // If we moved out of the nonant, we need update our map data
9286 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9287 add_msg( _( "The water puts out the flames!" ) );
9289 if( u.is_mounted() ) {
9290 monster *mon = u.mounted_creature.get();
9291 if( mon->has_effect( effect_onfire ) ) {
9293 }
9294 }
9295 }
9296
9297 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9298 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9299 // Immobile monsters can't be displaced.
9300 monster &critter = *mon_ptr;
9301 // TODO: handling for ridden creatures other than players mount.
9302 if( !critter.has_effect( effect_ridden ) ) {
9303 if( u.is_mounted() ) {
9304 std::vector<tripoint> valid;
9305 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9306 if( is_empty( jk ) ) {
9307 valid.push_back( jk );
9308 }
9309 }
9310 if( !valid.empty() ) {
9311 critter.move_to( random_entry( valid ) );
9312 add_msg( _( "You push the %s out of the way." ), critter.name() );
9313 } else {
9314 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9315 return u.pos().xy();
9316 }
9317 } else {
9318 critter.move_to( u.pos(), false,
9319 true ); // Force the movement even though the player is there right now.
9320 add_msg( _( "You displace the %s." ), critter.name() );
9321 }
9322 } else if( !u.has_effect( effect_riding ) ) {
9323 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9324 return u.pos().xy();
9325 }
9326 }
9327
9328 // If the player is in a vehicle, unboard them from the current part
9329 if( u.in_vehicle ) {
9330 m.unboard_vehicle( u.pos() );
9331 }
9332 // Move the player
9333 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9334 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9335 vertical_shift( dest_loc.z );
9336 }
9337
9338 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9339 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9340 vp1 ) ) {
9341 u.stop_hauling();
9342 }
9343 u.setpos( dest_loc );
9344 if( u.is_mounted() ) {
9345 monster *mon = u.mounted_creature.get();
9346 mon->setpos( dest_loc );
9347 mon->process_triggers();
9348 m.creature_in_field( *mon );
9349 }
9350 point submap_shift = update_map( u );
9351 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9352 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9353 // If you must use it you can calculate the position in the new, shifted system with
9354 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9355
9356 //Auto pulp or butcher and Auto foraging
9357 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9359
9360 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9361 if( forage_type != "off" ) {
9362 const auto forage = [&]( const tripoint & pos ) {
9363 const auto &xter_t = m.ter( pos ).obj().examine;
9364 const auto &xfurn_t = m.furn( pos ).obj().examine;
9365 const bool forage_everything = forage_type == "both";
9366 const bool forage_bushes = forage_everything || forage_type == "bushes";
9367 const bool forage_trees = forage_everything || forage_type == "trees";
9368 if( xter_t == &iexamine::none ) {
9369 return;
9370 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9371 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9372 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9373 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9374 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9375 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9376 ) {
9377 xter_t( u, pos );
9378 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9379 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9380 ) {
9381 xfurn_t( u, pos );
9382 }
9383 };
9384
9385 for( auto &elem : adjacentDir ) {
9386 forage( u.pos() + direction_XY( elem ) );
9387 }
9388 }
9389
9390 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9391 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9392 std::vector<item *> corpses;
9393
9394 for( item &it : m.i_at( u.pos() ) ) {
9395 corpses.push_back( &it );
9396 }
9397
9398 if( !corpses.empty() ) {
9399 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9400 for( item *it : corpses ) {
9401 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9402 }
9403 }
9404 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9405 const auto pulp = [&]( const tripoint & pos ) {
9406 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9407 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9408 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9410 u.activity.placement = m.getabs( pos );
9411 u.activity.auto_resume = true;
9412 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9413 return;
9414 }
9415 }
9416 };
9417
9418 if( pulp_butcher == "pulp_adjacent" ) {
9419 for( auto &elem : adjacentDir ) {
9420 pulp( u.pos() + direction_XY( elem ) );
9421 }
9422 } else {
9423 pulp( u.pos() );
9424 }
9425 }
9426 }
9427
9428 //Autopickup
9429 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9430 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9431 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9432 pickup::pick_up( u.pos(), -1 );
9433 }
9434
9435 // If the new tile is a boardable part, board it
9436 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9437 m.board_vehicle( u.pos(), &u );
9438 }
9439
9440 // Traps!
9441 // Try to detect.
9443 if( u.is_mounted() ) {
9445 } else {
9446 m.creature_on_trap( u );
9447 }
9448 // Drench the player if swimmable
9449 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9450 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9451 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9452 }
9453
9454 // List items here
9455 if( !m.has_flag( "SEALED", u.pos() ) ) {
9456 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9457 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9458 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9459 add_msg( _( "There's something here, but you can't see what it is." ) );
9460 } else if( m.has_items( u.pos() ) ) {
9461 std::vector<std::string> names;
9462 std::vector<size_t> counts;
9463 std::vector<item> items;
9464 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9465
9466 std::string next_tname = tmpitem.tname();
9467 std::string next_dname = tmpitem.display_name();
9468 bool by_charges = tmpitem.count_by_charges();
9469 bool got_it = false;
9470 for( size_t i = 0; i < names.size(); ++i ) {
9471 if( by_charges && next_tname == names[i] ) {
9472 counts[i] += tmpitem.charges;
9473 got_it = true;
9474 break;
9475 } else if( next_dname == names[i] ) {
9476 counts[i] += 1;
9477 got_it = true;
9478 break;
9479 }
9480 }
9481 if( !got_it ) {
9482 if( by_charges ) {
9483 names.push_back( tmpitem.tname( tmpitem.charges ) );
9484 counts.push_back( tmpitem.charges );
9485 } else {
9486 names.push_back( tmpitem.display_name( 1 ) );
9487 counts.push_back( 1 );
9488 }
9489 items.push_back( tmpitem );
9490 }
9491 if( names.size() > 10 ) {
9492 break;
9493 }
9494 }
9495 for( size_t i = 0; i < names.size(); ++i ) {
9496 if( !items[i].count_by_charges() ) {
9497 names[i] = items[i].display_name( counts[i] );
9498 } else {
9499 names[i] = items[i].tname( counts[i] );
9500 }
9501 }
9502 int and_the_rest = 0;
9503 for( size_t i = 0; i < names.size(); ++i ) {
9504 //~ number of items: "<number> <item>"
9505 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9506 names[i] = string_format( fmt, counts[i], names[i] );
9507 // Skip the first two.
9508 if( i > 1 ) {
9509 and_the_rest += counts[i];
9510 }
9511 }
9512 if( names.size() == 1 ) {
9513 add_msg( _( "You see here %s." ), names[0] );
9514 } else if( names.size() == 2 ) {
9515 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9516 } else if( names.size() == 3 ) {
9517 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9518 } else if( and_the_rest < 7 ) {
9519 add_msg( vgettext( "You see here %s, %s and %d more item.",
9520 "You see here %s, %s and %d more items.",
9521 and_the_rest ),
9522 names[0], names[1], and_the_rest );
9523 } else {
9524 add_msg( _( "You see here %s and many more items." ), names[0] );
9525 }
9526 }
9527 }
9528 }
9529
9530 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9531 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9532 add_msg( _( "There are vehicle controls here." ) );
9533 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9534 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9535 }
9536 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9537 u.is_mounted() ) {
9538 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9539 }
9540 return submap_shift;
9541}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:329
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1754
bool is_hauling() const
Definition: character.cpp:9189
void stop_hauling()
Definition: character.cpp:9180
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1620
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:10704
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6157
std::string furnname(const tripoint &p)
Definition: map.cpp:1469
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2322
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7846
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4771
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7835
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2312
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2298
void setpos(const tripoint &p) override
Definition: monster.cpp:238
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1527
void process_triggers()
Definition: monster.cpp:1212
cata::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
void search_surroundings()
Search surrounding squares for traps (and maybe other things in the future).
Definition: player.cpp:701
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3653
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3618
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2090
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2069
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2078
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2060
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3632
string_id< zone_type > zone_type_id
Definition: type_id.h:199

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9543 of file game.cpp.

9544{
9545 // if player is teleporting around, they don't bring their horse with them
9546 if( u.is_mounted() ) {
9548 u.mounted_creature->remove_effect( effect_ridden );
9549 u.mounted_creature = nullptr;
9550 }
9551 // offload the active npcs.
9552 unload_npcs();
9553 for( monster &critter : all_monsters() ) {
9554 despawn_monster( critter );
9555 }
9556 if( u.in_vehicle ) {
9557 m.unboard_vehicle( u.pos() );
9558 }
9559
9561 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9562 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9563 for( int z = minz; z <= maxz; z++ ) {
9564 m.clear_vehicle_list( z );
9565 }
9567 // offset because load_map expects the coordinates of the top left corner, but the
9568 // player will be centered in the middle of the map.
9569 // TODO: fix point types
9570 const tripoint map_sm_pos(
9571 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9572 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9573 load_map( map_sm_pos );
9574 load_npcs();
9575 m.spawn_monsters( true ); // Static monsters
9577 // update weather now as it could be different on the new location
9579 place_player( player_pos );
9580}
point place_player(const tripoint &dest)
Definition: game.cpp:9220
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:970
void update_overmap_seen()
Definition: game.cpp:10882
level_cache & access_cache(int zlev)
Definition: map.cpp:8745
void clear_vehicle_list(int zlev)
Definition: map.cpp:331
void clear_vehicle_cache()
Definition: map.cpp:313
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:351

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 866 of file game.cpp.

869{
870 std::vector<std::string> search_types = omt_search_types;
871 if( search_types.empty() ) {
872 vehicle veh( id );
873 if( veh.can_float() ) {
874 search_types.push_back( "river" );
875 search_types.push_back( "lake" );
876 } else {
877 search_types.push_back( "field" );
878 search_types.push_back( "road" );
879 }
880 }
881 for( const std::string &search_type : search_types ) {
882 omt_find_params find_params;
883 find_params.must_see = false;
884 find_params.cant_see = false;
885 find_params.types.emplace_back( search_type, ot_match_type::type );
886 // find nearest road
887 find_params.min_distance = min_distance;
888 find_params.search_range = max_distance;
889 // if player spawns underground, park their car on the surface.
890 const tripoint_abs_omt omt_origin( origin, 0 );
891 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
892 // try place vehicle there.
893 tinymap target_map;
894 target_map.load( project_to<coords::sm>( goal ), false );
895 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
896 static constexpr std::array<units::angle, 4> angles = {{
897 0_degrees, 90_degrees, 180_degrees, 270_degrees
898 }
899 };
900 vehicle *veh = target_map.add_vehicle(
901 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
902 if( veh ) {
903 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
904 veh->sm_pos = ms_to_sm_remain( abs_local );
905 veh->pos = abs_local.xy();
907 veh->tracking_on = true;
908 target_map.save();
909 return veh;
910 }
911 }
912 }
913 return nullptr;
914}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6607
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5607
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2108
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1916
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1901
bool tracking_on
Definition: vehicle.h:1991
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6699 of file game.cpp.

6702{
6703 // get global area info according to look_around caret position
6704 // TODO: fix point types
6706 lp ) ) ) );
6707 // we only need the area name and then pass it to print_all_tile_info() function below
6708 const std::string area_name = cur_ter_m->get_name();
6709 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6710}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:5877
point ms_to_omt_copy(const point &p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:205

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 5877 of file game.cpp.

5882{
5883 visibility_type visibility = VIS_HIDDEN;
5884 const bool inbounds = m.inbounds( lp );
5885 if( inbounds ) {
5886 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5887 }
5888 const Creature *creature = critter_at( lp, true );
5889 switch( visibility ) {
5890 case VIS_CLEAR: {
5891 const optional_vpart_position vp = m.veh_at( lp );
5892 print_terrain_info( lp, w_look, area_name, column, line );
5893 print_fields_info( lp, w_look, column, line );
5894 print_trap_info( lp, w_look, column, line );
5895 print_creature_info( creature, w_look, column, line, last_line );
5896 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
5897 last_line );
5898 print_items_info( lp, w_look, column, line, last_line );
5899 print_graffiti_info( lp, w_look, column, line, last_line );
5900 }
5901 break;
5902 case VIS_BOOMER:
5903 case VIS_BOOMER_DARK:
5904 case VIS_DARK:
5905 case VIS_LIT:
5906 case VIS_HIDDEN:
5907 print_visibility_info( w_look, column, line, visibility );
5908
5909 if( creature != nullptr ) {
5910 std::vector<std::string> buf;
5911 if( u.sees_with_infrared( *creature ) ) {
5912 creature->describe_infrared( buf );
5913 } else if( u.sees_with_specials( *creature ) ) {
5914 creature->describe_specials( buf );
5915 }
5916 for( const std::string &s : buf ) {
5917 mvwprintw( w_look, point( 1, ++line ), s );
5918 }
5919 }
5920 break;
5921 }
5922 if( !inbounds ) {
5923 return;
5924 }
5925 auto this_sound = sounds::sound_at( lp );
5926 if( !this_sound.empty() ) {
5927 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
5928 } else {
5929 // Check other z-levels
5930 tripoint tmp = lp;
5931 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
5932 if( tmp.z == lp.z ) {
5933 continue;
5934 }
5935
5936 auto zlev_sound = sounds::sound_at( tmp );
5937 if( !zlev_sound.empty() ) {
5938 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
5939 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
5940 }
5941 }
5942 }
5943}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6425
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6047
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:5974
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6141
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6085
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6094
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6103
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:5945
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6065
void line(map *m, const ter_id &type, const point &p1, const point &p2)
Definition: mapgen.cpp:6462
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6085 of file game.cpp.

6087{
6088 int vLines = last_line - line;
6089 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
6090 line = creature->print_info( w_look, ++line, vLines, column );
6091 }
6092}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6047 of file game.cpp.

6049{
6050 const field &tmpfield = m.field_at( lp );
6051 for( auto &fld : tmpfield ) {
6052 const field_entry &cur = fld.second;
6053 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
6054 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
6055 const int max_width = getmaxx( w_look ) - column - 2;
6056 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
6057 get_fire_fuel_string( lp ) ) - 1;
6058 line += lines;
6059 } else {
6060 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
6061 }
6062 }
6063}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:625
ter_id t_pit
Definition: mapdata.cpp:625

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6141 of file game.cpp.

6144{
6145 if( line > last_line ) {
6146 return;
6147 }
6148
6149 const int max_width = getmaxx( w_look ) - column - 2;
6150 if( m.has_graffiti_at( lp ) ) {
6151 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6152 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6153 m.graffiti_at( lp ) );
6154 }
6155}
ter_id t_grave_new
Definition: mapdata.cpp:625

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6103 of file game.cpp.

6107{
6108 if( !m.sees_some_items( lp, u ) ) {
6109 return;
6110 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
6111 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
6112 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
6113 mvwprintz( w_look, point( column, ++line ), c_yellow,
6114 _( "There's something there, but you can't see what it is." ) );
6115 return;
6116 } else {
6117 std::map<std::string, int> item_names;
6118 for( auto &item : m.i_at( lp ) ) {
6119 ++item_names[item.tname()];
6120 }
6121
6122 const int max_width = getmaxx( w_look ) - column - 1;
6123 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
6124 // last line but not last item
6125 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
6126 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
6127 break;
6128 }
6129
6130 if( it->second > 1 ) {
6131 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
6132 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
6133 it->first.c_str(), it->second );
6134 } else {
6135 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
6136 }
6137 }
6138 }
6139}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4747
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 5974 of file game.cpp.

5977{
5978 const int max_width = getmaxx( w_look ) - column - 1;
5979 int lines;
5980
5981 const auto fmt_tile_info = []( const tripoint & lp ) {
5982 map &here = get_map();
5983 std::string ret;
5984 if( debug_mode ) {
5985 ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
5986 if( here.has_furn( lp ) ) {
5987 ret += "; " + here.furn( lp )->id.str();
5988 }
5989 } else {
5990 ret = here.tername( lp );
5991 if( here.has_furn( lp ) ) {
5992 ret += "; " + here.furnname( lp );
5993 }
5994 }
5995 return ret;
5996 };
5997
5998 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
5999
6000 if( m.impassable( lp ) ) {
6001 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6002 _( "%s; Impassable" ),
6003 tile );
6004 } else {
6005 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6006 _( "%s; Movement cost %d" ),
6007 tile, m.move_cost( lp ) * 50 );
6008
6009 const auto ll = get_light_level( std::max( 1.0,
6010 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
6011 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
6012 wprintz( w_look, ll.second, ll.first );
6013 }
6014
6015 std::string signage = m.get_signage( lp );
6016 if( !signage.empty() ) {
6017 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6018 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
6019 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
6020 }
6021
6022 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
6023 // Print info about stuff below
6024 tripoint below( lp.xy(), lp.z - 1 );
6025 std::string tile_below = fmt_tile_info( below );
6026
6027 if( !m.has_floor_or_support( lp ) ) {
6028 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6029 _( "Below: %s; No support" ),
6030 tile_below );
6031 } else {
6032 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6033 _( "Below: %s; Walkable" ),
6034 tile_below );
6035 }
6036 }
6037
6038 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6039 m.features( lp ) );
6040 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
6041 m.coverage( lp ) );
6042 if( line < lines ) {
6043 line = lines + map_features - 1;
6044 }
6045}
Manage and cache data about a part of the map.
Definition: map.h:384
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2039
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:646
std::string features(const tripoint &p)
Definition: map.cpp:1714
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6256
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:496
ter_str_id id
Definition: mapdata.h:461

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6065 of file game.cpp.

6068{
6069 const trap &tr = m.tr_at( lp );
6070 if( tr.can_see( lp, u ) ) {
6071 partial_con *pc = m.partial_con_at( lp );
6072 std::string tr_name;
6073 if( pc && tr.loadid == tr_unfinished_construction ) {
6074 const construction &built = pc->id.obj();
6075 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.group->name(),
6076 pc->counter / 100000 );
6077 } else {
6078 tr_name = tr.name();
6079 }
6080
6081 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
6082 }
6083}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5153
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string name() const
construction_group_str_id group
Definition: construction.h:50
construction_id id
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::group, partial_con::id, line(), trap::loadid, m, mvwprintz(), construction_group::name(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6094 of file game.cpp.

6096{
6097 if( veh ) {
6098 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
6099 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
6100 }
6101}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 5945 of file game.cpp.

5947{
5948 const char *visibility_message = nullptr;
5949 switch( visibility ) {
5950 case VIS_CLEAR:
5951 visibility_message = _( "Clearly visible." );
5952 break;
5953 case VIS_BOOMER:
5954 visibility_message = _( "A bright pink blur." );
5955 break;
5956 case VIS_BOOMER_DARK:
5957 visibility_message = _( "A pink blur." );
5958 break;
5959 case VIS_DARK:
5960 visibility_message = _( "Darkness." );
5961 break;
5962 case VIS_LIT:
5963 visibility_message = _( "Bright light." );
5964 break;
5965 case VIS_HIDDEN:
5966 visibility_message = _( "Unseen." );
5967 break;
5968 }
5969
5970 mvwprintw( w_look, point( line, column ), visibility_message );
5971 line += 2;
5972}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1762 of file game.cpp.

1763{
1764 if( !u.activity ) {
1765 return;
1766 }
1767
1768 while( u.moves > 0 && u.activity ) {
1769 u.activity.do_turn( u );
1770 }
1771}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11455 of file game.cpp.

11456{
11457 const bool worn = p.is_worn( it );
11458 const bool wielded = ( &it == &p.weapon );
11459 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11460 if( worn ) {
11461 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11462 effects.insert( effects.end(), ew.begin(), ew.end() );
11463 }
11464 if( wielded ) {
11465 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11466 effects.insert( effects.end(), ew.begin(), ew.end() );
11467 }
11468
11469 if( it.is_tool() ) {
11470 // Recharge it if necessary
11471 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11472 //Before incrementing charge, check that any extra requirements are met
11473 if( check_art_charge_req( it ) ) {
11474 switch( it.type->artifact->charge_type ) {
11475 case ARTC_NULL:
11476 case NUM_ARTCS:
11477 break; // dummy entries
11478 case ARTC_TIME:
11479 // Once per hour
11480 if( calendar::once_every( 1_hours ) ) {
11481 it.charges++;
11482 }
11483 break;
11484 case ARTC_SOLAR:
11485 if( calendar::once_every( 10_minutes ) &&
11486 is_in_sunlight( p.pos() ) ) {
11487 it.charges++;
11488 }
11489 break;
11490 // Artifacts can inflict pain even on Deadened folks.
11491 // Some weird Lovecraftian thing. ;P
11492 // (So DON'T route them through mod_pain!)
11493 case ARTC_PAIN:
11494 if( calendar::once_every( 1_minutes ) ) {
11495 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11496 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11497 it.charges++;
11498 }
11499 break;
11500 case ARTC_HP:
11501 if( calendar::once_every( 1_minutes ) ) {
11502 add_msg( m_bad, _( "You feel your body decaying." ) );
11503 p.hurtall( 1, nullptr );
11504 it.charges++;
11505 }
11506 break;
11507 case ARTC_FATIGUE:
11508 if( calendar::once_every( 1_minutes ) ) {
11509 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11510 u.mod_fatigue( 3 * rng( 1, 3 ) );
11511 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11512 it.charges++;
11513 }
11514 break;
11515 // Portals are energetic enough to charge the item.
11516 // Tears in reality are consumed too, but can't charge it.
11517 case ARTC_PORTAL:
11518 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11519 m.remove_field( dest, fd_fatigue );
11520 if( m.tr_at( dest ).loadid == tr_portal ) {
11521 add_msg( m_good, _( "The portal collapses!" ) );
11522 m.remove_trap( dest );
11523 it.charges++;
11524 break;
11525 }
11526 }
11527 break;
11528 }
11529 }
11530 }
11531 }
11532
11533 for( const art_effect_passive &i : effects ) {
11534 switch( i ) {
11535 case AEP_STR_UP:
11536 p.mod_str_bonus( +4 );
11537 break;
11538 case AEP_DEX_UP:
11539 p.mod_dex_bonus( +4 );
11540 break;
11541 case AEP_PER_UP:
11542 p.mod_per_bonus( +4 );
11543 break;
11544 case AEP_INT_UP:
11545 p.mod_int_bonus( +4 );
11546 break;
11547 case AEP_ALL_UP:
11548 p.mod_str_bonus( +2 );
11549 p.mod_dex_bonus( +2 );
11550 p.mod_per_bonus( +2 );
11551 p.mod_int_bonus( +2 );
11552 break;
11553 case AEP_SPEED_UP:
11554 // Handled in player::current_speed()
11555 break;
11556
11557 case AEP_PBLUE:
11558 if( p.get_rad() > 0 ) {
11559 p.mod_rad( -1 );
11560 }
11561 break;
11562
11563 case AEP_SMOKE:
11564 if( one_in( 10 ) ) {
11565 tripoint pt( p.posx() + rng( -1, 1 ),
11566 p.posy() + rng( -1, 1 ),
11567 p.posz() );
11568 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11569 }
11570 break;
11571
11572 case AEP_SNAKES:
11573 break; // Handled in player::hit()
11574
11575 case AEP_EXTINGUISH:
11576 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11577 m.mod_field_age( dest, fd_fire, -1_turns );
11578 }
11579 break;
11580
11581 case AEP_FUN:
11582 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11583 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11584 break;
11585
11586 case AEP_HUNGER:
11587 if( one_in( 100 ) ) {
11588 p.mod_stored_kcal( -10 );
11589 }
11590 break;
11591
11592 case AEP_THIRST:
11593 if( one_in( 120 ) ) {
11594 p.mod_thirst( 1 );
11595 }
11596 break;
11597
11598 case AEP_EVIL:
11599 if( one_in( 150 ) ) { // Once every 15 minutes, on average
11600 p.add_effect( effect_evil, 30_minutes );
11601 if( it.is_armor() ) {
11602 if( !worn ) {
11603 add_msg( _( "You have an urge to wear the %s." ),
11604 it.tname() );
11605 }
11606 } else if( !wielded ) {
11607 add_msg( _( "You have an urge to wield the %s." ),
11608 it.tname() );
11609 }
11610 }
11611 break;
11612
11613 case AEP_SCHIZO:
11614 break; // Handled in player::suffer()
11615
11616 case AEP_RADIOACTIVE:
11617 if( one_in( 4 ) ) {
11618 p.irradiate( 1.0f );
11619 }
11620 break;
11621
11622 case AEP_STR_DOWN:
11623 p.mod_str_bonus( -3 );
11624 break;
11625
11626 case AEP_DEX_DOWN:
11627 p.mod_dex_bonus( -3 );
11628 break;
11629
11630 case AEP_PER_DOWN:
11631 p.mod_per_bonus( -3 );
11632 break;
11633
11634 case AEP_INT_DOWN:
11635 p.mod_int_bonus( -3 );
11636 break;
11637
11638 case AEP_ALL_DOWN:
11639 p.mod_str_bonus( -2 );
11640 p.mod_dex_bonus( -2 );
11641 p.mod_per_bonus( -2 );
11642 p.mod_int_bonus( -2 );
11643 break;
11644
11645 case AEP_SPEED_DOWN:
11646 break; // Handled in player::current_speed()
11647
11648 default:
11649 //Suppress warnings
11650 break;
11651 }
11652 }
11653 // Recalculate, as it might have changed (by mod_*_bonus above)
11654 p.str_cur = p.get_str();
11655 p.int_cur = p.get_int();
11656 p.dex_cur = p.get_dex();
11657 p.per_cur = p.get_per();
11658}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4184
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4179
int str_cur
Definition: character.h:247
void mod_rad(int mod)
Definition: character.cpp:7186
virtual int get_dex() const
Definition: character.cpp:4068
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4299
bool is_worn(const item &thing) const
Definition: character.h:1082
virtual int get_int() const
Definition: character.cpp:4076
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4430
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4174
int int_cur
Definition: character.h:249
int get_rad() const
Definition: character.cpp:7176
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9096
virtual int get_per() const
Definition: character.cpp:4072
void mod_stamina(int mod)
Definition: character.cpp:7213
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8666
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1531
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4189
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1352
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:4985
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7247
bool is_tool() const
Definition: item.cpp:6824
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7274
int charges
Definition: item.h:2196
bool is_armor() const
Definition: item.cpp:6575
const itype * type
Definition: item.h:2157
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5408
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5328
void remove_trap(const tripoint &p)
Definition: map.cpp:5273
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:866

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1722 of file game.cpp.

1723{
1724 if( u.has_effect( effect_sleep ) ) {
1725 // Can't interrupt
1726 return;
1727 }
1728
1729 bool has_activity = u.activity && u.activity.moves_left > 0;
1730 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1731
1732 if( !has_activity && !is_travelling ) {
1733 // Nohing to interrupt
1734 return;
1735 }
1736
1737 // Key poll may be quite expensive, so limit it to 10 times per second.
1738 static auto last_poll = std::chrono::steady_clock::now();
1739 auto now = std::chrono::steady_clock::now();
1740 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1741 ( now - last_poll ).count();
1742
1743 if( difference > 100 ) {
1745 last_poll = now;
1746 }
1747
1748 // If player is performing a task and a monster is dangerously close, warn them
1749 // regardless of previous safemode warnings.
1750 // Distraction Manager can change this.
1751 if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1753 Creature *hostile_critter = is_hostile_very_close();
1754 if( hostile_critter != nullptr ) {
1756 string_format( _( "The %s is dangerously close!" ),
1757 hostile_critter->get_name() ) );
1758 }
1759 }
1760}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9227
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:2083
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8832 of file game.cpp.

8833{
8834 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8835
8836 if( !harmful_stuff.empty() &&
8837 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
8838 return false;
8839 }
8840 if( !harmful_stuff.empty() && u.is_mounted() &&
8841 m.tr_at( dest_loc ).loadid == tr_ledge ) {
8842 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
8843 u.mounted_creature->get_name() );
8844 return false;
8845 }
8846 return true;
8847}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11423 of file game.cpp.

11424{
11425 const WORLDPTR active_world = world_generator->active_world;
11426 if( active_world == nullptr ) {
11427 return;
11428 }
11429
11430 if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
11431 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11432 MAPBUFFER.reset();
11434 try {
11435 setup();
11436 } catch( const std::exception &err ) {
11437 debugmsg( "Error: %s", err.what() );
11438 }
11440 }
11441 } else {
11442 popup_getkey( _( "No saves for %s yet." ), u.name );
11443 }
11444}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2620
void setup()
Definition: game.cpp:577
static save_t from_player_name(const std::string &name)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:500
bool save_exists(const save_t &name) const

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11401 of file game.cpp.

11402{
11403 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11404 if( !moves_since_last_save ) {
11405 return;
11406 }
11407 add_msg( m_info, _( "Saving game, this may take a while" ) );
11408
11410 popup.message( "%s", _( "Saving game, this may take a while" ) );
11413
11414 time_t now = time( nullptr ); //timestamp for start of saving procedure
11415
11416 //perform save
11417 save();
11418 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11420 last_save_timestamp = now;
11421}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 565 of file game.cpp.

566{
567 if( was_fullscreen ) {
568 if( !fullscreen ) {
570 }
571 }
572}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 979 of file game.cpp.

980{
981 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
982 // and not invoke "on_load" for those NPCs that avoided unloading this way.
983 unload_npcs();
984 load_npcs();
985}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( )

Definition at line 529 of file game.cpp.

530{
531#if defined(TILES)
532 // Disable UIs below to avoid accessing the tile context during loading.
534 try {
535 tilecontext->reinit();
536 std::vector<mod_id> dummy;
537 tilecontext->load_tileset(
538 get_option<std::string>( "TILES" ),
539 world_generator->active_world ? world_generator->active_world->active_mod_order : dummy,
540 /*precheck=*/false,
541 /*force=*/true,
542 /*pump_events=*/true
543 );
544 tilecontext->do_tile_loading_report();
545 } catch( const std::exception &err ) {
546 popup( _( "Loading the tileset failed: %s" ), err.what() );
547 }
548 g->reset_zoom();
549 g->mark_main_ui_adaptor_resize();
550#endif // TILES
551}

References _, g, popup(), and world_generator.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2360 of file game.cpp.

2361{
2363 return remoteveh_cache;
2364 }
2366 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2367 if( remote_veh_string.str().empty() ||
2369 remoteveh_cache = nullptr;
2370 } else {
2371 tripoint vp;
2372 remote_veh_string >> vp.x >> vp.y >> vp.z;
2373 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2374 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2375 remoteveh_cache = veh;
2376 } else {
2377 remoteveh_cache = nullptr;
2378 }
2379 }
2380 return remoteveh_cache;
2381}
vehicle * remoteveh_cache
Definition: game.h:1071
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3359
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1992 of file game.cpp.

1993{
1994 follower_ids.erase( id );
1995 u.follower_ids.erase( id );
1996}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 4864 of file game.cpp.

4865{
4866 critter_tracker->remove( critter );
4867}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 10921 of file game.cpp.

10922{
10923 for( auto &elem : coming_to_stairs ) {
10924 elem.staircount = 0;
10925 const tripoint pnt( elem.pos().xy(), get_levz() );
10926 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
10927 }
10928
10929 coming_to_stairs.clear();
10930}
std::vector< monster > coming_to_stairs
Definition: game.h:1009

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7296 of file game.cpp.

7298{
7299 const int width = getmaxx( window );
7300 for( int i = 1; i < TERMX; i++ ) {
7301 if( i < width ) {
7302 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7303 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7304 LINE_OXOX ); // -
7305 }
7306
7307 if( i < TERMY - height ) {
7308 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7309 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7310 }
7311 }
7312
7313 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7314 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7315
7316 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7317 LINE_XXXO ); // |-
7318 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7319 LINE_XOXX ); // -|
7320
7321 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7322 wprintz( window, c_white, _( "Items" ) );
7323
7324 std::string sSort;
7325 if( bRadiusSort ) {
7326 //~ Sort type: distance.
7327 sSort = _( "<s>ort: dist" );
7328 } else {
7329 //~ Sort type: category.
7330 sSort = _( "<s>ort: cat" );
7331 }
7332
7333 int letters = utf8_width( sSort );
7334
7335 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7336
7337 std::vector<std::string> tokens;
7338 if( !sFilter.empty() ) {
7339 tokens.emplace_back( _( "<R>eset" ) );
7340 }
7341
7342 tokens.emplace_back( _( "<E>xamine" ) );
7343 tokens.emplace_back( _( "<C>ompare" ) );
7344 tokens.emplace_back( _( "<F>ilter" ) );
7345 tokens.emplace_back( _( "<+/->Priority" ) );
7346
7347 int gaps = tokens.size() + 1;
7348 letters = 0;
7349 int n = tokens.size();
7350 for( int i = 0; i < n; i++ ) {
7351 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7352 }
7353
7354 int usedwidth = letters;
7355 const int gap_spaces = ( width - usedwidth ) / gaps;
7356 usedwidth += gap_spaces * gaps;
7357 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7358
7359 for( int i = 0; i < n; i++ ) {
7360 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7361 tokens[i] ) + gap_spaces;
7362 }
7363}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3723 of file game.cpp.

3724{
3725 for( float &lev : latest_lightlevels ) {
3726 lev = -std::numeric_limits<float>::max();
3727 }
3728}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 2798 of file game.cpp.

2799{
2800 for( auto elem : follower_ids ) {
2801 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
2802 if( !npc_to_get ) {
2803 continue;
2804 }
2805 npc *npc_to_add = npc_to_get.get();
2806 npc_to_add->chatbin.missions.clear();
2807 npc_to_add->chatbin.missions_assigned.clear();
2808 npc_to_add->mission = NPC_MISSION_NULL;
2809 npc_to_add->chatbin.mission_selected = nullptr;
2810 npc_to_add->set_attitude( NPCATT_NULL );
2811 npc_to_add->op_of_u.anger = 0;
2812 npc_to_add->op_of_u.fear = 0;
2813 npc_to_add->op_of_u.trust = 0;
2814 npc_to_add->op_of_u.value = 0;
2815 npc_to_add->op_of_u.owed = 0;
2816 npc_to_add->set_fac( faction_id( "no_faction" ) );
2818 npc_to_add->global_omt_location(),
2819 npc_to_add->getID() ) );
2820
2821 }
2822
2823}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3144
npc_chatbin chatbin
Definition: npc.h:1329
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2640
npc_opinion op_of_u
Definition: npc.h:1328
void set_fac(const faction_id &id)
Definition: npc.cpp:466
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:752
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:757
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:748
int value
Definition: npc.h:242
int trust
Definition: npc.h:240
int owed
Definition: npc.h:244
int fear
Definition: npc.h:241
int anger
Definition: npc.h:243

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7211 of file game.cpp.

7212{
7213#if defined(TILES)
7215 rescale_tileset( tileset_zoom );
7216#endif // TILES
7217}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 4995 of file game.cpp.

4996{
4997 if( !it.is_corpse() ) {
4998 debugmsg( "Tried to revive a non-corpse." );
4999 return false;
5000 }
5001 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
5002 ( it.get_mtype()->id );
5003 monster &critter = *newmon_ptr;
5004 critter.init_from_item( it );
5005 if( critter.get_hp() < 1 ) {
5006 // Failed reanimation due to corpse being too burned
5007 return false;
5008 }
5009 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
5010 it.has_flag( "QUARTERED" ) ) {
5011 // Failed reanimation due to corpse being butchered
5012 return false;
5013 }
5014
5015 critter.no_extra_death_drops = true;
5016 critter.add_effect( effect_downed, 5_turns, num_bp );
5017 for( const item &component : it.components ) {
5018 critter.corpse_components.push_back( component );
5019 }
5020
5021 if( it.get_var( "zlave" ) == "zlave" ) {
5022 critter.add_effect( effect_pacified, 1_turns, num_bp );
5023 critter.add_effect( effect_pet, 1_turns, num_bp );
5024 }
5025
5026 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
5027 for( auto &ammo : critter.ammo ) {
5028 ammo.second = 0;
5029 }
5030 }
5031
5032 return place_critter_at( newmon_ptr, p );
5033}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4792
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1025
const mtype * get_mtype() const
Definition: item.cpp:6496
std::list< item > components
Definition: item.h:2159
bool has_flag(const std::string &flag) const
Definition: item.cpp:5213
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6491
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2918
bool no_extra_death_drops
Definition: monster.h:483
std::vector< item > corpse_components
Definition: monster.h:460
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2782
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 2899 of file game.cpp.

2900{
2901 try {
2902 if( !save_player_data() ||
2904 !save_artifacts() ||
2905 !save_maps() ||
2906 !get_auto_pickup().save_character() ||
2908 !get_safemode().save_character() ||
2909 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
2910 JsonOut jsout( fout );
2911 uistate.serialize( jsout );
2912 }, _( "uistate data" ) ) ) {
2913 return false;
2914 } else {
2915 world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
2916 return true;
2917 }
2918 } catch( std::ios::failure &err ) {
2919 popup( _( "Failed to save game data" ) );
2920 return false;
2921 }
2922}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:580
bool save_player_data()
Definition: game.cpp:2853
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 2834 of file game.cpp.

2835{
2836 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
2837 return ::save_artifacts( artfilename );
2838}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 5056 of file game.cpp.

5057{
5058 int assist_bonus = installer.get_effect_int( effect_assisted );
5059
5060 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
5063 -1 );
5064
5065 int damage = cyborg->damage();
5066 int dmg_lvl = cyborg->damage_level( 4 );
5067 int difficulty = 12;
5068
5069 if( damage != 0 ) {
5070
5071 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
5072 dmg_lvl );
5073
5074 // Damage of the cyborg increases difficulty
5075 difficulty += dmg_lvl;
5076 }
5077
5078 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
5079 int success = chance_of_success - rng( 1, 100 );
5080
5081 if( !g->u.query_yn(
5082 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
5083 100 - static_cast<int>( chance_of_success ) ) ) {
5084 return;
5085 }
5086
5087 if( success > 0 ) {
5088 add_msg( m_good, _( "Successfully removed Personality override." ) );
5089 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
5090
5091 delete_cyborg_item( g->m, couch_pos, cyborg );
5092
5093 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
5094 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5095 tmp->normalize();
5096 tmp->load_npc_template( npc_cyborg );
5097 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
5099 tmp->hurtall( dmg_lvl * 10, nullptr );
5100 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
5101 load_npcs();
5102
5103 } else {
5104 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
5105 adjusted_skill ) );
5106 const int fail_type = std::min( 5, failure_level );
5107 switch( fail_type ) {
5108 case 1:
5109 case 2:
5110 add_msg( m_info, _( "The removal fails." ) );
5111 add_msg( m_bad, _( "The body is damaged." ) );
5112 cyborg->set_damage( damage + 1000 );
5113 break;
5114 case 3:
5115 case 4:
5116 add_msg( m_info, _( "The removal fails badly." ) );
5117 add_msg( m_bad, _( "The body is badly damaged!" ) );
5118 cyborg->set_damage( damage + 2000 );
5119 break;
5120 case 5:
5121 add_msg( m_info, _( "The removal is a catastrophe." ) );
5122 add_msg( m_bad, _( "The body is destroyed!" ) );
5123 delete_cyborg_item( g->m, couch_pos, cyborg );
5124 break;
5125 default:
5126 break;
5127 }
5128
5129 }
5130
5131}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1886
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1843
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:714
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:701
int damage() const
How much damage has the item sustained?
Definition: item.cpp:696
static const skill_id skill_computer("computer")
static void delete_cyborg_item(map &m, const tripoint &couch_pos, item *cyborg)
Definition: game.cpp:5035
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), delete_cyborg_item(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), overmapbuffer::insert_npc(), load_npcs(), m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 2826 of file game.cpp.

2827{
2828 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
2829 return write_to_file( masterfile, [&]( std::ostream & fout ) {
2830 serialize_master( fout );
2831 }, _( "factions data" ) );
2832}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1243

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 2840 of file game.cpp.

2841{
2842 try {
2843 m.save();
2844 overmap_buffer.save(); // can throw
2845 MAPBUFFER.save(); // can throw
2846 return true;
2847 } catch( const std::exception &err ) {
2848 popup( _( "Failed to save the maps: %s" ), err.what() );
2849 return false;
2850 }
2851}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:103

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 2853 of file game.cpp.

2854{
2855 const std::string playerfile = get_player_base_save_path();
2856
2857 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
2858 serialize( fout );
2859 }, _( "player data" ) );
2860 const bool saved_map_memory = u.save_map_memory();
2861 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
2862 std::ostream & fout ) {
2863 fout << memorial().dump();
2864 }, _( "player memorial" ) );
2865#if defined(__ANDROID__)
2866 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
2867 std::ostream & fout ) {
2868 save_shortcuts( fout );
2869 }, _( "quick shortcuts" ) );
2870#endif
2871 const bool saved_diary = u.get_avatar_diary()->store();
2872 return saved_data && saved_map_memory && saved_log && saved_diary
2873#if defined(__ANDROID__)
2874 && saved_shortcuts
2875#endif
2876 ;
2877}
bool save_map_memory()
Definition: avatar.cpp:131
bool store()
Definition: diary.cpp:760
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12138
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), avatar::get_avatar_diary(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), diary::store(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:1001
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1243 of file savegame.cpp.

1244{
1245 fout << "# version " << savegame_version << std::endl;
1246 try {
1247 JsonOut json( fout, true ); // pretty-print
1248 json.start_object();
1249
1250 json.member( "next_mission_id", next_mission_id );
1251 json.member( "next_npc_id", next_npc_id );
1252
1253 json.member( "active_missions" );
1254 mission::serialize_all( json );
1255
1256 json.member( "factions", *faction_manager_ptr );
1257 json.member( "seed", seed );
1258
1259 json.member( "weather" );
1260 json.start_object();
1261 json.member( "lightning", get_weather().lightning_active );
1262 json.end_object();
1263
1264 json.end_object();
1265 } catch( const JsonError &e ) {
1266 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1267 }
1268}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1234

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1900 of file game.cpp.

1901{
1902 critter_died = true;
1903}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( const point p)

Definition at line 1710 of file game.cpp.

1711{
1712 // remove the previous driving offset,
1713 // store the new offset and apply the new offset.
1720}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1895 of file game.cpp.

1896{
1897 npcs_dirty = true;
1898}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 8759 of file game.cpp.

8760{
8761 safe_mode = mode;
8763}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7219 of file game.cpp.

7220{
7221#if defined(TILES)
7222 if( tileset_zoom != level ) {
7223 tileset_zoom = level;
7224 rescale_tileset( tileset_zoom );
7225 }
7226#else
7227 static_cast<void>( level );
7228#endif // TILES
7229}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2383 of file game.cpp.

2384{
2386 remoteveh_cache = veh;
2387 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2389 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2390 veh = nullptr;
2391 }
2392
2393 if( veh == nullptr ) {
2394 u.remove_value( "remote_controlling_vehicle" );
2395 return;
2396 }
2397
2398 std::stringstream remote_veh_string;
2399 const tripoint vehpos = veh->global_pos3();
2400 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2401 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2402}
void remove_value(const std::string &key)
Definition: creature.cpp:1336

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 577 of file game.cpp.

578{
579 loading_ui ui( true );
580 {
583 popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
586
588 }
589
591
592 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
593 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
594 }
595
596 m = map( get_option<bool>( "ZLEVELS" ) );
597
599 next_mission_id = 1;
600 new_game = true;
601 uquit = QUIT_NO; // We haven't quit the game
602 bVMonsterLookFire = true;
603
604 // invalidate calendar caches in case we were previously playing
605 // a different world
606 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
607 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
608
611
612 turnssincelastmon = 0; //Auto safe mode init
613
616 coming_to_stairs.clear();
617 active_npc.clear();
618 faction_manager_ptr->clear();
623
624 SCT.vSCT.clear(); //Delete pending messages
625
626 stats().clear();
627 // reset kill counts
628 kill_tracker_ptr->clear();
630 // reset follower list
631 follower_ids.clear();
632 scent.reset();
633
635 remoteveh_cache = nullptr;
636
637 token_provider_ptr->clear();
638 // back to menu for save loading, new game etc
639}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:4869
void load_world_modfiles(loading_ui &ui)
Loads core data and mods from the active world.
Definition: game.cpp:2733
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void reset_sounds()
Definition: sounds.cpp:565

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4722 of file game.cpp.

4723{
4724 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4725 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4726 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4727 }
4728 if( critter.is_monster() ) {
4729 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4730 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4731 return std::dynamic_pointer_cast<T>( mon_ptr );
4732 }
4733 }
4734 }
4735 if( critter.is_npc() ) {
4736 for( auto &cur_npc : active_npc ) {
4737 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4738 return std::dynamic_pointer_cast<T>( cur_npc );
4739 }
4740 }
4741 }
4742 return nullptr;
4743}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( const point delta)

Definition at line 12151 of file game.cpp.

12152{
12153 for( tripoint &p : destination_preview ) {
12154 p += delta;
12155 }
12156}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11156 of file game.cpp.

11157{
11158 // If either shift argument is non-zero, we're shifting.
11159 if( shift == tripoint_zero ) {
11160 return;
11161 }
11162 for( monster &critter : all_monsters() ) {
11163 if( shift.xy() != point_zero ) {
11164 critter.shift( shift.xy() );
11165 }
11166
11167 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11168 // We're inbounds, so don't despawn after all.
11169 // No need to shift Z-coordinates, they are absolute
11170 continue;
11171 }
11172 // Either a vertical shift or the critter is now outside of the reality bubble,
11173 // anyway: it must be saved and removed.
11174 despawn_monster( critter );
11175 }
11176 // The order in which zombies are shifted may cause zombies to briefly exist on
11177 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11178 critter_tracker->rebuild_cache();
11179}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12158 of file game.cpp.

12159{
12160 ///\EFFECT_DEX decreases chances of slipping while climbing
12161 int climb = u.dex_cur;
12162 if( u.has_trait( trait_BADKNEES ) ) {
12163 climb = climb / 2;
12164 }
12165 if( one_in( climb ) ) {
12166 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12167 if( climb <= 1 ) {
12168 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12169 }
12170 return true;
12171 }
12172 return false;
12173}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 4880 of file game.cpp.

4881{
4882 if( one_in( 100 ) ) {
4883 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
4884 tmp->normalize();
4885 tmp->randomize( NC_HALLU );
4886 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
4887 if( !critter_at( p, true ) ) {
4889 load_npcs();
4890 return true;
4891 } else {
4892 return false;
4893 }
4894 }
4895
4897 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
4898 phantasm->hallucination = true;
4899 phantasm->spawn( p );
4900
4901 //Don't attempt to place phantasms inside of other creatures
4902 if( !critter_at( phantasm->pos(), true ) ) {
4903 return critter_tracker->add( phantasm );
4904 } else {
4905 return false;
4906 }
4907}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 2894 of file game.cpp.

2895{
2896 return *spell_events_ptr;
2897}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 11720 of file game.cpp.

11721{
11722 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
11723 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
11724 scen->has_flag( "SUM_ADV_START" );
11725
11727 if( scen_season ) {
11728 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
11730 get_option<int>( "INITIAL_TIME" );
11731 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
11732 if( scen->has_flag( "SPR_START" ) ) {
11734 } else if( scen->has_flag( "SUM_START" ) ) {
11737 } else if( scen->has_flag( "AUT_START" ) ) {
11740 } else if( scen->has_flag( "WIN_START" ) ) {
11743 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
11746 } else {
11747 debugmsg( "The Unicorn" );
11748 }
11749 } else {
11750 // No scenario, so use the starting date+time configured in world options
11751 int initial_days = get_option<int>( "INITIAL_DAY" );
11752 if( initial_days == -1 ) {
11753 // 0 - 363 for a 91 day season
11754 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
11755 }
11757
11758 // Determine the season based off how long the seasons are set to be
11759 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
11760 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
11761 if( season_number == 0 ) {
11763 } else if( season_number == 1 ) {
11765 } else if( season_number == 2 ) {
11767 } else {
11769 }
11770
11772 + 1_hours * get_option<int>( "INITIAL_TIME" )
11773 + 1_days * get_option<int>( "SPAWN_DELAY" );
11774 }
11775
11777}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:1008
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 665 of file game.cpp.

666{
667 if( !gamemode ) {
668 gamemode = std::make_unique<special_game>();
669 }
670
671 seed = rng_bits();
672 new_game = true;
675 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
676 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
679
681
684 popup.message( "%s", _( "Please wait as we build your world" ) );
687
688 load_master();
689 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
690
694 do {
695 omtstart = start_loc.find_player_initial_location();
696 if( omtstart == overmap::invalid_tripoint ) {
697 if( query_yn(
698 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
701 } else {
702 return false;
703 }
704 }
705 } while( omtstart == overmap::invalid_tripoint );
706
707 start_loc.prepare_map( omtstart );
708
709 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
710 if( u.starting_vehicle &&
711 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
712 std::vector<std::string> {} ) ) {
713 debugmsg( "could not place starting vehicle" );
714 }
715
716 if( scen->has_map_extra() ) {
717 // Map extras can add monster spawn points and similar and should be done before the main
718 // map is loaded.
719 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
720 }
721
722 // TODO: fix point types
723 tripoint lev = project_to<coords::sm>( omtstart ).raw();
724 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
725 lev.x -= HALF_MAPSIZE;
726 lev.y -= HALF_MAPSIZE;
727 load_map( lev, /*pump_events=*/true );
728
731 // Do this after the map cache has been built!
732 start_loc.place_player( u );
733 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
736 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
738 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
739
740 u.moves = 0;
741 u.process_turn(); // process_turn adds the initial move points
745 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
747
748 //Reset character safe mode/pickup rules
753
754 //Put some NPCs in there!
755 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
756 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
757 !g->scen->has_flag( "LONE_START" ) ) ) {
759 }
760 //Load NPCs. Set nearby npcs to active.
761 load_npcs();
762 // Spawn the monsters
763 const bool spawn_near =
764 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
765 // Surrounded start ones
766 if( spawn_near ) {
767 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
768 }
769
770 m.spawn_monsters( !spawn_near ); // Static monsters
771
772 // Make sure that no monsters are near the player
773 // This can happen in lab starts
774 if( !spawn_near ) {
775 for( monster &critter : all_monsters() ) {
776 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
777 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
778 remove_zombie( critter );
779 }
780 }
781 }
782
783 //Create mutation_category_level
785 //Calculate mutation drench protection stats
788 if( scen->has_flag( "FIRE_START" ) ) {
789 start_loc.burn( omtstart, 3, 3 );
790 }
791 if( scen->has_flag( "INFECTED" ) ) {
793 }
794 if( scen->has_flag( "BAD_DAY" ) ) {
795 u.add_effect( effect_flu, 1000_minutes );
796 u.add_effect( effect_drunk, 270_minutes );
797 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
798 }
799 if( scen->has_flag( "HELI_CRASH" ) ) {
800 start_loc.handle_heli_crash( u );
801 bool success = false;
802 for( auto v : m.get_vehicles() ) {
803 std::string name = v.v->type.str();
804 std::string search = std::string( "helicopter" );
805 if( name.find( search ) != std::string::npos ) {
806 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
807 const tripoint pos = vp.pos();
808 u.setpos( pos );
809
810 // Delete the items that would have spawned here from a "corpse"
811 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
812 vehicle_stack here = v.v->get_items( sp );
813
814 for( auto iter = here.begin(); iter != here.end(); ) {
815 iter = here.erase( iter );
816 }
817 }
818
819 auto mons = critter_tracker->find( pos );
820 if( mons != nullptr ) {
821 critter_tracker->remove( *mons );
822 }
823
824 success = true;
825 break;
826 }
827 if( success ) {
828 v.v->name = "Bird Wreckage";
829 break;
830 }
831 }
832 }
833 }
834 if( scen->has_flag( "BORDERED" ) ) {
835 overmap &starting_om = get_cur_om();
836 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
837 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
839 }
840
841 }
842 for( auto &e : u.inv_dump() ) {
843 e->set_owner( g->u );
844 }
845 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
846 update_map( u );
847 // Profession pets
848 for( const mtype_id &elem : u.starting_pets ) {
849 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
850 mon->friendly = -1;
851 mon->add_effect( effect_pet, 1_turns, num_bp );
852 } else {
853 add_msg( m_debug, "cannot place starting pet, no space!" );
854 }
855 }
856 // Assign all of this scenario's missions to the player.
857 for( const mission_type_id &m : scen->missions() ) {
858 const auto mission = mission::reserve_new( m, character_id() );
859 mission->assign( u );
860 }
861
862 g->events().send<event_type::game_start>( u.getID() );
863 return true;
864}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:364
bool last_climate_control_ret
Definition: character.h:2215
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7946
void set_stamina(int new_stamina)
Definition: character.cpp:7208
time_point next_climate_control_check
Definition: character.h:2214
int get_stamina_max() const
Definition: character.cpp:7199
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7923
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:11720
void create_starting_npcs()
Definition: game.cpp:992
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:12018
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:866
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6407
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2163
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:594
vproto_id starting_vehicle
Definition: player.h:606
std::vector< mtype_id > starting_pets
Definition: player.h:607
start_location_id start_location
Definition: player.h:595
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:58
iterator erase(const_iterator it) override
Definition: vehicle.cpp:230
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< overmap_special > overmap_special_id
Definition: type_id.h:134
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:105
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_distraction_manager(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, distraction_manager::distraction_manager_gui::load(), safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10519 of file game.cpp.

10520{
10521 // Find target items and quantities thereof for the new activity
10522 std::vector<item_location> target_items;
10523 std::vector<int> quantities;
10524
10525 map_stack items = m.i_at( pos );
10526 for( item &it : items ) {
10527 // Liquid cannot be picked up
10528 if( it.made_of( LIQUID ) ) {
10529 continue;
10530 }
10531 target_items.emplace_back( map_cursor( pos ), &it );
10532 // Quantity of 0 means move all
10533 quantities.push_back( 0 );
10534 }
10535
10536 if( target_items.empty() ) {
10537 // Nothing to haul
10538 return;
10539 }
10540
10541 // Whether the destination is inside a vehicle (not supported)
10542 const bool to_vehicle = false;
10543 // Destination relative to the player
10544 const tripoint relative_destination{};
10545
10547 target_items,
10548 quantities,
10549 to_vehicle,
10550 relative_destination
10551 ) ) );
10552}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 2884 of file game.cpp.

2885{
2886 return *stats_tracker_ptr;
2887}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 4909 of file game.cpp.

4910{
4911 if( &a == &b ) {
4912 // No need to do anything, but print a debugmsg anyway
4913 debugmsg( "Tried to swap %s with itself", a.disp_name() );
4914 return true;
4915 }
4916 if( critter_at( a.pos() ) != &a ) {
4917 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4918 b.disp_name(), critter_at( a.pos() )->disp_name() );
4919 return false;
4920 }
4921 if( critter_at( b.pos() ) != &b ) {
4922 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4923 a.disp_name(), critter_at( b.pos() )->disp_name() );
4924 return false;
4925 }
4926 // Simplify by "sorting" the arguments
4927 // Only the first argument can be u
4928 // If swapping player/npc with a monster, monster is second
4929 bool a_first = a.is_player() ||
4930 ( a.is_npc() && !b.is_player() );
4931 Creature &first = a_first ? a : b;
4932 Creature &second = a_first ? b : a;
4933 // Possible options:
4934 // both first and second are monsters
4935 // second is a monster, first is a player or an npc
4936 // first is a player, second is an npc
4937 // both first and second are npcs
4938 if( first.is_monster() ) {
4939 monster *m1 = dynamic_cast< monster * >( &first );
4940 monster *m2 = dynamic_cast< monster * >( &second );
4941 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
4942 debugmsg( "Couldn't swap two monsters" );
4943 return false;
4944 }
4945
4946 critter_tracker->swap_positions( *m1, *m2 );
4947 return true;
4948 }
4949
4950 player *u_or_npc = dynamic_cast< player * >( &first );
4951 player *other_npc = dynamic_cast< player * >( &second );
4952
4953 if( u_or_npc->in_vehicle ) {
4954 m.unboard_vehicle( u_or_npc->pos() );
4955 }
4956
4957 if( other_npc && other_npc->in_vehicle ) {
4958 m.unboard_vehicle( other_npc->pos() );
4959 }
4960
4961 tripoint temp = second.pos();
4962 second.setpos( first.pos() );
4963
4964 if( first.is_player() ) {
4965 walk_move( temp );
4966 } else {
4967 first.setpos( temp );
4968 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4969 m.board_vehicle( u_or_npc->pos(), u_or_npc );
4970 }
4971 }
4972
4973 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4974 m.board_vehicle( other_npc->pos(), other_npc );
4975 }
4976 return true;
4977}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:8898
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7288 of file game.cpp.

7289{
7290 popup( _( "This binary was not compiled with tiles support." ) );
7291 return false;
7292}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7282 of file game.cpp.

7283{
7284 popup( _( "This binary was not compiled with tiles support." ) );
7285 return false;
7286}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 555 of file game.cpp.

556{
557 if( fullscreen ) {
558 was_fullscreen = true;
560 } else {
561 was_fullscreen = false;
562 }
563}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11327 of file game.cpp.

11328{
11330}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 508 of file game.cpp.

509{
510#if !defined(TILES)
513#else
514 toggle_fullscreen_window();
515#endif
516}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_gate()

void game::toggle_gate ( const tripoint p)

Definition at line 5279 of file game.cpp.

5280{
5281 gates::toggle_gate( p, u );
5282}
void toggle_gate(const tripoint &pos, player &p)
opens/closes the gate via player's activity
Definition: gates.cpp:236

References gates::toggle_gate(), and u.

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 518 of file game.cpp.

519{
520#if defined(TILES)
522 clear_window_area( w_pixel_minimap );
523 }
526#endif // TILES
527}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2404 of file game.cpp.

2405{
2406 bool new_destination = true;
2407 if( !destination_preview.empty() ) {
2408 auto &final_destination = destination_preview.back();
2409 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2410 // Second click
2411 new_destination = false;
2413 destination_preview.clear();
2415 if( act == ACTION_NULL ) {
2416 // Something went wrong
2418 return false;
2419 }
2420 }
2421 }
2422
2423 if( new_destination ) {
2425 u.get_path_avoid() );
2426 return false;
2427 }
2428
2429 return true;
2430}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2432 of file game.cpp.

2433{
2434 const bool cleared_destination = !destination_preview.empty();
2436 destination_preview.clear();
2437
2438 if( cleared_destination ) {
2439 // Produce no-op if auto-move had just been cleared on this action
2440 // e.g. from a previous single left mouse click. This has the effect
2441 // of right-click canceling an auto-move before it is initiated.
2442 return false;
2443 }
2444
2445 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2446 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2447 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2448 if( !u.sees( *mon ) ) {
2449 add_msg( _( "Nothing relevant here." ) );
2450 return false;
2451 }
2452
2453 if( !u.weapon.is_gun() ) {
2454 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2455 return false;
2456 }
2457
2458 // TODO: Add weapon range check. This requires weapon to be reloaded.
2459
2460 act = ACTION_FIRE;
2461 } else if( is_adjacent &&
2462 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2463 true ) ) {
2464 act = ACTION_CLOSE;
2465 } else if( is_self ) {
2467 } else if( is_adjacent ) {
2469 } else {
2470 add_msg( _( "Nothing relevant here." ) );
2471 return false;
2472 }
2473
2474 return true;
2475}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:3974
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 970 of file game.cpp.

971{
972 for( const auto &npc : active_npc ) {
973 npc->on_unload();
974 }
975
976 active_npc.clear();
977}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2645

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map(
207 tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ),
208 /*pump_events=*/true
209 );
210
211 safe_mode = static_cast<safe_mode_type>( tmprun );
212 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
214 }
215
216 std::string linebuff;
217 std::string linebuf;
218 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
219 scent.deserialize( linebuf );
220 scent.deserialize( linebuff, true );
221 } else {
222 scent.reset();
223 }
224 data.read( "active_monsters", *critter_tracker );
225
226 coming_to_stairs.clear();
227 for( auto elem : data.get_array( "stair_monsters" ) ) {
228 monster stairtmp;
229 elem.read( stairtmp );
230 coming_to_stairs.push_back( stairtmp );
231 }
232
233 if( data.has_object( "kill_tracker" ) ) {
234 data.read( "kill_tracker", *kill_tracker_ptr );
235 } else {
236 // Legacy support for when kills were stored directly in game
237 std::map<mtype_id, int> kills;
238 std::vector<std::string> npc_kills;
239 for( const JsonMember member : data.get_object( "kills" ) ) {
240 kills[mtype_id( member.name() )] = member.get_int();
241 }
242
243 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
244 npc_kills.push_back( npc_name );
245 }
246
247 kill_tracker_ptr->reset( kills, npc_kills );
248 }
249
250 data.read( "player", u );
252 data.read( "stats_tracker", *stats_tracker_ptr );
253 data.read( "achievements_tracker", *achievements_tracker_ptr );
254 data.read( "token_provider", token_provider_ptr );
256 Messages::deserialize( data );
257
258 } catch( const JsonError &jsonerr ) {
259 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
260 return;
261 }
262}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:361
bool has_object(const std::string &name) const
Definition: json.cpp:425
JsonArray get_array(const std::string &name) const
Definition: json.cpp:332
int get_int(const std::string &name) const
Definition: json.cpp:282
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:944
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:264
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:407
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), inp_mngr, kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, input_manager::pump_events(), JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1193 of file savegame.cpp.

1194{
1196 chkversion( fin );
1197 if( savegame_loading_version < 11 ) {
1198 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1199 popup->message(
1200 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1204 }
1205 try {
1206 // single-pass parsing example
1207 JsonIn jsin( fin );
1208 jsin.start_object();
1209 while( !jsin.end_object() ) {
1210 std::string name = jsin.get_member_name();
1211 if( name == "next_mission_id" ) {
1212 next_mission_id = jsin.get_int();
1213 } else if( name == "next_npc_id" ) {
1214 next_npc_id.deserialize( jsin );
1215 } else if( name == "active_missions" ) {
1217 } else if( name == "factions" ) {
1218 jsin.read( *faction_manager_ptr );
1219 } else if( name == "seed" ) {
1220 jsin.read( seed );
1221 } else if( name == "weather" ) {
1222 JsonObject w = jsin.get_object();
1223 w.read( "lightning", get_weather().lightning_active );
1224 } else {
1225 // silently ignore anything else
1226 jsin.skip_value();
1227 }
1228 }
1229 } catch( const JsonError &e ) {
1230 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1231 }
1232}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1183

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 10787 of file game.cpp.

10788{
10789 point shift;
10790
10791 while( x < HALF_MAPSIZE_X ) {
10792 x += SEEX;
10793 shift.x--;
10794 }
10795 while( x >= HALF_MAPSIZE_X + SEEX ) {
10796 x -= SEEX;
10797 shift.x++;
10798 }
10799 while( y < HALF_MAPSIZE_Y ) {
10800 y += SEEY;
10801 shift.y--;
10802 }
10803 while( y >= HALF_MAPSIZE_Y + SEEY ) {
10804 y -= SEEY;
10805 shift.y++;
10806 }
10807
10808 if( shift == point_zero ) {
10809 // adjust player position
10810 u.setpos( tripoint( x, y, get_levz() ) );
10811 // Update what parts of the world map we can see
10812 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
10813 // TODO: only make this call if we changed z-level
10815 // Not actually shifting the submaps, all the stuff below would do nothing
10816 return point_zero;
10817 }
10818
10819 // this handles loading/unloading submaps that have scrolled on or off the viewport
10820 // NOLINTNEXTLINE(cata-use-named-point-constants)
10821 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
10822 point remaining_shift = shift;
10823 while( remaining_shift != point_zero ) {
10824 point this_shift = clamp( remaining_shift, size_1 );
10825 m.shift( this_shift );
10826 remaining_shift -= this_shift;
10827 }
10828
10829 grid_tracker_ptr->load( m );
10830
10831 // Shift monsters
10832 shift_monsters( tripoint( shift, 0 ) );
10833 const point shift_ms = sm_to_ms_copy( shift );
10834 u.shift_destination( -shift_ms );
10835
10836 // Shift NPCs
10837 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
10838 ( *it )->shift( shift );
10839 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
10840 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
10841 //Remove the npc from the active list. It remains in the overmap list.
10842 ( *it )->on_unload();
10843 it = active_npc.erase( it );
10844 } else {
10845 it++;
10846 }
10847 }
10848
10849 scent.shift( shift_ms );
10850
10851 // Also ensure the player is on current z-level
10852 // get_levz() should later be removed, when there is no longer such a thing
10853 // as "current z-level"
10854 u.setpos( tripoint( x, y, get_levz() ) );
10855
10856 // Only do the loading after all coordinates have been shifted.
10857
10858 // Check for overmap saved npcs that should now come into view.
10859 // Put those in the active list.
10860 load_npcs();
10861
10862 // Make sure map cache is consistent since it may have shifted.
10863 if( m.has_zlevels() ) {
10864 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
10865 m.invalidate_map_cache( zlev );
10866 }
10867 } else {
10869 }
10871
10872 // Spawn monsters if appropriate
10873 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
10874 m.spawn_monsters( false ); // Static monsters
10875
10876 // Update what parts of the world map we can see
10878
10879 return shift;
10880}
void shift_destination(const point &shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11156
void shift(const point &s)
Shift the map along the vector s.
Definition: map.cpp:6779
void shift(const point &sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(const point &p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 10781 of file game.cpp.

10782{
10783 point p2( p.posx(), p.posy() );
10784 return update_map( p2.x, p2.y );
10785}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 10882 of file game.cpp.

10883{
10884 const tripoint_abs_omt ompos = u.global_omt_location();
10885 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
10886 const int dist_squared = dist * dist;
10887 // We can always see where we're standing
10888 overmap_buffer.set_seen( ompos, true );
10889 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
10890 const point_rel_omt delta = p.xy() - ompos.xy();
10891 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
10892 if( trigdist && h_squared > dist_squared ) {
10893 continue;
10894 }
10895 if( delta == point_rel_omt() ) {
10896 // 1. This case is already handled outside of the loop
10897 // 2. Calculating multiplier would cause division by zero
10898 continue;
10899 }
10900 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
10901 point abs_delta = delta.raw().abs();
10902 int max_delta = std::max( abs_delta.x, abs_delta.y );
10903 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
10904 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
10905 float sight_points = dist;
10906 for( auto it = line.begin();
10907 it != line.end() && sight_points >= 0; ++it ) {
10908 const oter_id &ter = overmap_buffer.ter( *it );
10909 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
10910 }
10911 if( sight_points >= 0 ) {
10912 tripoint_abs_omt seen( p );
10913 do {
10914 overmap_buffer.set_seen( seen, true );
10915 --seen.z();
10916 } while( seen.z() >= 0 );
10917 }
10918 }
10919}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:771
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:230

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 10934 of file game.cpp.

10935{
10936 // Search for the stairs closest to the player.
10937 std::vector<int> stairx;
10938 std::vector<int> stairy;
10939 std::vector<int> stairdist;
10940
10941 const bool from_below = monstairz < get_levz();
10942
10943 if( coming_to_stairs.empty() ) {
10944 return;
10945 }
10946
10947 if( m.has_zlevels() ) {
10948 debugmsg( "%d monsters coming to stairs on a map with z-levels",
10949 coming_to_stairs.size() );
10950 coming_to_stairs.clear();
10951 }
10952
10953 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
10954 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
10955 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
10956 stairx.push_back( dest.x );
10957 stairy.push_back( dest.y );
10958 stairdist.push_back( rl_dist( dest, u.pos() ) );
10959 }
10960 }
10961 if( stairdist.empty() ) {
10962 return; // Found no stairs?
10963 }
10964
10965 // Find closest stairs.
10966 size_t si = 0;
10967 for( size_t i = 0; i < stairdist.size(); i++ ) {
10968 if( stairdist[i] < stairdist[si] ) {
10969 si = i;
10970 }
10971 }
10972
10973 // Find up to 4 stairs for distance stairdist[si] +1
10974 std::vector<int> nearest;
10975 nearest.push_back( si );
10976 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
10977 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
10978 nearest.push_back( i );
10979 }
10980 }
10981 // Randomize the stair choice
10982 si = random_entry_ref( nearest );
10983
10984 // Attempt to spawn zombies.
10985 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
10986 point mpos( stairx[si], stairy[si] );
10987 monster &critter = coming_to_stairs[i];
10988 const tripoint dest {
10989 mpos, g->get_levz()
10990 };
10991
10992 // We might be not be visible.
10993 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
10994 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
10995 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
10996 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
10997 continue;
10998 }
10999
11000 critter.staircount -= 4;
11001 // Let the player know zombies are trying to come.
11002 if( u.sees( dest ) ) {
11003 std::string dump;
11004 if( critter.staircount > 4 ) {
11005 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
11006 } else {
11007 if( critter.staircount > 0 ) {
11008 dump += ( from_below ?
11009 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
11010 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
11011 critter.name(),
11012 m.tername( dest ) ) :
11013 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
11014 critter.name(),
11015 m.tername( dest ) ) );
11016 }
11017 }
11018
11019 add_msg( m_warning, dump );
11020 } else {
11022 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
11023 }
11024
11025 if( critter.staircount > 0 ) {
11026 continue;
11027 }
11028
11029 if( is_empty( dest ) ) {
11030 critter.spawn( dest );
11031 critter.staircount = 0;
11032 place_critter_at( make_shared_fast<monster>( critter ), dest );
11033 if( u.sees( dest ) ) {
11034 if( !from_below ) {
11035 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
11036 critter.name(),
11037 m.tername( dest ) );
11038 } else {
11039 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
11040 critter.name(),
11041 m.tername( dest ) );
11042 }
11043 }
11044 coming_to_stairs.erase( coming_to_stairs.begin() + i );
11045 continue;
11046 } else if( u.pos() == dest ) {
11047 // Monster attempts to push player of stairs
11049 int tries = 0;
11050
11051 // the critter is now right on top of you and will attack unless
11052 // it can find a square to push you into with one of his tries.
11053 const int creature_push_attempts = 9;
11054 const int player_throw_resist_chance = 3;
11055
11056 critter.spawn( dest );
11057 while( tries < creature_push_attempts ) {
11058 tries++;
11059 push.x = rng( -1, 1 );
11060 push.y = rng( -1, 1 );
11061 point ipos( mpos + push );
11062 tripoint pos( ipos, get_levz() );
11063 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
11064 critter.can_move_to( pos ) ) {
11065 bool resiststhrow = ( u.is_throw_immune() ) ||
11067 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
11068 u.moves -= 25; // small charge for avoiding the push altogether
11069 add_msg( _( "The %s fails to push you back!" ),
11070 critter.name() );
11071 return; //judo or leg brace prevent you from getting pushed at all
11072 }
11073 // Not accounting for tentacles latching on, so..
11074 // Something is about to happen, lets charge half a move
11075 u.moves -= 50;
11076 if( resiststhrow && ( u.is_throw_immune() ) ) {
11077 //we have a judoka who isn't getting pushed but counterattacking now.
11078 mattack::thrown_by_judo( &critter );
11079 return;
11080 }
11081 std::string msg;
11082 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
11083 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
11084 // dodge 12 - never get downed
11085 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
11086 u.add_effect( effect_downed, 2_turns );
11087 msg = _( "The %s pushed you back hard!" );
11088 } else {
11089 msg = _( "The %s pushed you back!" );
11090 }
11091 add_msg( m_warning, msg.c_str(), critter.name() );
11092 u.setx( u.posx() + push.x );
11093 u.sety( u.posy() + push.y );
11094 return;
11095 }
11096 }
11098 _( "The %s tried to push you back but failed! It attacks you!" ),
11099 critter.name() );
11100 critter.melee_attack( u );
11101 u.moves -= 50;
11102 return;
11103 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
11104 // Monster attempts to displace a monster from the stairs
11105 monster &other = *mon_ptr;
11106 critter.spawn( dest );
11107
11108 // the critter is now right on top of another and will push it
11109 // if it can find a square to push it into inside of his tries.
11110 const int creature_push_attempts = 9;
11111 const int creature_throw_resist = 4;
11112
11113 int tries = 0;
11114 point push2;
11115 while( tries < creature_push_attempts ) {
11116 tries++;
11117 push2.x = rng( -1, 1 );
11118 push2.y = rng( -1, 1 );
11119 point ipos2( mpos + push2 );
11120 tripoint pos( ipos2, get_levz() );
11121 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
11122 continue;
11123 }
11124 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
11125 other.setpos( tripoint( ipos2, get_levz() ) );
11126 other.moves -= 50;
11127 std::string msg;
11128 if( one_in( creature_throw_resist ) ) {
11129 other.add_effect( effect_downed, 2_turns );
11130 msg = _( "The %1$s pushed the %2$s hard." );
11131 } else {
11132 msg = _( "The %1$s pushed the %2$s." );
11133 }
11134 add_msg( m_neutral, msg, critter.name(), other.name() );
11135 return;
11136 }
11137 }
11138 return;
11139 }
11140 }
11141}
void setx(int x)
Definition: character.h:788
void sety(int y)
Definition: character.h:791
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:812
int monstairz
Definition: game.h:1010
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8638
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:258
int posy() const override
Definition: monster.h:501
void melee_attack(Creature &target)
Definition: monster.cpp:1389
int staircount
Definition: monster.h:512
void spawn(const tripoint &p)
Definition: monster.cpp:482
int posx() const override
Definition: monster.h:498
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4672
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 4859 of file game.cpp.

4860{
4861 return critter_tracker->update_pos( critter, pos );
4862}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4642 of file game.cpp.

4643{
4644 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4645 add_msg( m_info, _( "You can not read a computer screen!" ) );
4646 return;
4647 }
4648 if( u.is_blind() ) {
4649 // we don't have screen readers in game
4650 add_msg( m_info, _( "You can not see a computer screen!" ) );
4651 return;
4652 }
4653 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4654 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4655 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4656 return;
4657 }
4658
4659 computer *used = m.computer_at( p );
4660
4661 if( used == nullptr ) {
4662 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4663 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4664 } else {
4665 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4666 }
4667 return;
4668 }
4669
4670 computer_session( *used ).use();
4671}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5554
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 2064 of file game.cpp.

2065{
2066 basecamp camp = m.hoist_submap_camp( u.pos() );
2067 if( camp.is_valid() ) {
2068 overmap_buffer.add_camp( camp );
2070 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
2071 std::string camp_name = _( "Faction Camp" );
2072 camp.set_name( camp_name );
2073 overmap_buffer.add_camp( camp );
2075 }
2076}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5585
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5580
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 2006 of file game.cpp.

2007{
2008 for( auto &veh : m.get_vehicles() ) {
2009 vehicle *v = veh.v;
2012 if( other_v ) {
2013 // the other vehicle is towing us.
2014 v->tow_data.set_towing( other_v, v );
2016 }
2017 }
2018 }
2019}
tripoint other_towing_point
Definition: vehicle.h:167
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:6117
towing_data tow_data
Definition: vehicle.h:1944

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 2021 of file game.cpp.

2022{
2023 for( monster &m : all_monsters() ) {
2024 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
2025 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
2026 if( !mounted_pl ) {
2027 // Target no longer valid.
2028 m.mounted_player_id = character_id();
2029 m.remove_effect( effect_ridden );
2030 continue;
2031 }
2032 mounted_pl->mounted_creature = shared_from( m );
2033 mounted_pl->setpos( m.pos() );
2034 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
2035 m.mounted_player = mounted_pl;
2036 }
2037 }
2038}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 2040 of file game.cpp.

2041{
2042 // Make sure visible followers are in the list.
2043 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
2044 return guy.is_player_ally();
2045 } );
2046 for( npc *guy : visible_followers ) {
2047 update_faction_api( guy );
2048 add_npc_follower( guy->getID() );
2049 }
2050 // Make sure overmapbuffered NPC followers are in the list.
2051 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
2052 npc *guy = temp_guy.get();
2053 if( guy->is_player_ally() ) {
2054 update_faction_api( guy );
2055 add_npc_follower( guy->getID() );
2056 }
2057 }
2058 // Make sure that serialized player followers sync up with game list
2059 for( const auto &temp_id : u.follower_ids ) {
2060 add_npc_follower( temp_id );
2061 }
2062}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1986
static void update_faction_api(npc *guy)
Definition: game.cpp:1998

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10108 of file game.cpp.

10109{
10110 if( u.is_mounted() ) {
10111 auto mons = u.mounted_creature.get();
10112 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
10113 if( !mons->check_mech_powered() ) {
10114 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
10115 mons->get_name() );
10116 return;
10117 }
10118 }
10119 }
10120
10121 // > and < are used for diving underwater.
10122 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
10123 if( movez == -1 ) {
10124 if( u.is_underwater() ) {
10125 add_msg( m_info, _( "You are already underwater!" ) );
10126 return;
10127 }
10128 if( u.worn_with_flag( "FLOTATION" ) ) {
10129 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
10130 return;
10131 }
10132 u.set_underwater( true );
10133 ///\EFFECT_STR increases breath-holding capacity while diving
10134 u.oxygen = 30 + 2 * u.str_cur;
10135 add_msg( _( "You dive underwater!" ) );
10136 } else {
10137 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10138 u.set_underwater( false );
10139 add_msg( _( "You surface." ) );
10140 } else {
10141 add_msg( m_info, _( "You try to surface but can't!" ) );
10142 }
10143 }
10144 u.moves -= 100;
10145 return;
10146 }
10147
10148 // Force means we're going down, even if there's no staircase, etc.
10149 bool climbing = false;
10150 int move_cost = 100;
10151 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10152 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10153 // Climbing
10154 if( m.has_floor_or_support( stairs ) ) {
10155 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10156 return;
10157 }
10158
10159 std::vector<tripoint> pts;
10160 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10161 if( m.passable( pt ) &&
10162 m.has_floor_or_support( pt ) ) {
10163 pts.push_back( pt );
10164 }
10165 }
10166
10167 const int cost = map_funcs::climbing_cost( m, u.pos(), stairs );
10168
10169 if( cost == 0 ) {
10170 if( u.has_trait( trait_WEB_ROPE ) ) {
10171 if( pts.empty() ) {
10172 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10173 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10174 if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
10175 add_msg( m_info, _( "You can't spin a web rope there." ) );
10176 } else if( g->m.has_furn( u.pos() ) ) {
10177 add_msg( m_info, _( "There is already furniture at that location." ) );
10178 } else {
10179 if( query_yn( "Spin a rope and climb?" ) ) {
10180 add_msg( m_good, _( "You spin a rope of web." ) );
10181 g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10182 u.mod_moves( to_turns<int>( 2_seconds ) );
10184 vertical_move( movez, force, peeking );
10185 }
10186 }
10187 }
10188
10189 } else {
10190 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10191
10192 }
10193 return;
10194
10195 }
10196
10197 if( cost <= 0 || pts.empty() ) {
10198 add_msg( m_info,
10199 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10200 return;
10201 } else {
10202 // TODO: Make it an extended action
10203 climbing = true;
10204 move_cost = cost;
10205
10207 if( !pnt ) {
10208 return;
10209 }
10210 stairs = *pnt;
10211 }
10212 }
10213
10214 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10215 add_msg( m_info, _( "You can't go down here!" ) );
10216 return;
10217 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10218 add_msg( m_info, _( "You can't go up here!" ) );
10219 return;
10220 }
10221
10222 if( force ) {
10223 // Let go of a grabbed cart.
10224 u.grab( OBJECT_NONE );
10225 } else if( u.grab_point != tripoint_zero ) {
10226 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10227 return;
10228 }
10229
10230 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10231 // is called or when the map is loaded on new z-level (== false).
10232 // This caches the z-level we start the movement on (current) and the level we're want to end.
10233 const int z_before = get_levz();
10234 const int z_after = get_levz() + movez;
10235 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10236 debugmsg( "Tried to move outside allowed range of z-levels" );
10237 return;
10238 }
10239
10240 if( !u.move_effects( false ) ) {
10241 return;
10242 }
10243
10244 // Check if there are monsters are using the stairs.
10245 bool slippedpast = false;
10246 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10247 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10248 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10249 coming_to_stairs[0].name() );
10250 // Roll.
10251 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10252
10253 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10254 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10255 ///\EFFECT_STR increases chance of moving past monsters on stairs
10256
10257 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10258 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10259 if( coming_to_stairs.size() > 4 ) {
10260 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10261 dexroll /= 4;
10262 strroll /= 2;
10263 } else if( coming_to_stairs.size() > 1 ) {
10264 add_msg( m_warning, _( "There's something else behind it!" ) );
10265 dexroll /= 2;
10266 }
10267
10268 if( dexroll < 14 || strroll < 12 ) {
10270 u.moves -= 100;
10271 return;
10272 }
10273
10274 add_msg( _( "You manage to slip past!" ) );
10275 slippedpast = true;
10276 u.moves -= 100;
10277 }
10278
10279 // Shift the map up or down
10280
10281 std::unique_ptr<map> tmp_map_ptr;
10282 if( !m.has_zlevels() ) {
10283 tmp_map_ptr = std::make_unique<map>();
10284 }
10285
10286 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10287 if( m.has_zlevels() ) {
10288 // We no longer need to shift the map here! What joy
10289 } else {
10290 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10291 }
10292
10293 // Find the corresponding staircase
10294 bool rope_ladder = false;
10295 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10296 if( !force && !climbing ) {
10297 const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10298 if( !pnt ) {
10299 return;
10300 }
10301 stairs = *pnt;
10302 }
10303
10304 if( !force ) {
10305 monstairz = z_before;
10306 }
10307 // Save all monsters that can reach the stairs, remove them from the tracker,
10308 // then despawn the remaining monsters. Because it's a vertical shift, all
10309 // monsters are out of the bounds of the map and will despawn.
10310 shared_ptr_fast<monster> stored_mount;
10311 if( u.is_mounted() && !m.has_zlevels() ) {
10312 // Store a *copy* of the mount, so we can remove the original monster instance
10313 // from the tracker before the map shifts.
10314 // Map shifting would otherwise just despawn the mount and would later respawn it.
10315 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10317 }
10318 if( !m.has_zlevels() ) {
10319 const tripoint to = u.pos();
10320 for( monster &critter : all_monsters() ) {
10321 // if its a ladder instead of stairs - most zombies can't climb that.
10322 // unless that have a special flag to allow them to do so.
10323 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10324 critter.has_effect( effect_ridden ) ||
10325 critter.has_effect( effect_tied ) ) {
10326 continue;
10327 }
10328 int turns = critter.turns_to_reach( to.xy() );
10329 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10330 && !slippedpast ) {
10331 critter.staircount = 10 + turns;
10332 critter.on_unload();
10333 coming_to_stairs.push_back( critter );
10334 remove_zombie( critter );
10335 }
10336 }
10337 auto mons = critter_tracker->find( g->u.pos() );
10338 if( mons != nullptr ) {
10339 critter_tracker->remove( *mons );
10340 }
10341 shift_monsters( tripoint( 0, 0, movez ) );
10342 }
10343
10344 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10345 std::vector<monster *> monsters_following;
10346 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10347 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10348 [this]( const shared_ptr_fast<npc> &np ) {
10349 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10350 rl_dist( np->pos(), u.pos() ) < 2;
10351 } );
10352 }
10353
10354 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10355 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10356 for( monster &critter : all_monsters() ) {
10357 if( ladder && !critter.climbs() ) {
10358 continue;
10359 }
10360 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10361 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10362 !critter.has_effect( effect_tied ) ) ) {
10363 monsters_following.push_back( &critter );
10364 }
10365 }
10366 }
10367
10368 if( u.is_mounted() ) {
10369 monster *crit = u.mounted_creature.get();
10370 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10371 crit->use_mech_power( -1 );
10372 if( u.movement_mode_is( CMM_WALK ) ) {
10373 crit->use_mech_power( -2 );
10374 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10375 crit->use_mech_power( -1 );
10376 } else if( u.movement_mode_is( CMM_RUN ) ) {
10377 crit->use_mech_power( -3 );
10378 }
10379 }
10380 } else {
10381 u.moves -= move_cost;
10382 }
10383 for( const auto &np : npcs_to_bring ) {
10384 if( np->in_vehicle ) {
10385 m.unboard_vehicle( np->pos() );
10386 }
10387 }
10388 const tripoint old_pos = g->u.pos();
10389 point submap_shift;
10390 vertical_shift( z_after );
10391 if( !force ) {
10392 submap_shift = update_map( stairs.x, stairs.y );
10393 }
10394
10395 // if an NPC or monster is on the stiars when player ascends/descends
10396 // they may end up merged on th esame tile, do some displacement to resolve that.
10397 // if, in the weird case of it not being possible to displace;
10398 // ( how did the player even manage to approach the stairs, if so? )
10399 // then nothing terrible happens, its just weird.
10400 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10401 std::string crit_name;
10402 bool player_displace = false;
10404 if( displace.has_value() ) {
10405 npc *guy = g->critter_at<npc>( u.pos(), true );
10406 if( guy ) {
10407 crit_name = guy->get_name();
10408 tripoint old_pos = guy->pos();
10409 if( !guy->is_enemy() ) {
10410 guy->move_away_from( u.pos(), true );
10411 if( old_pos != guy->pos() ) {
10412 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10413 }
10414 } else {
10415 player_displace = true;
10416 }
10417 }
10418 monster *mon = g->critter_at<monster>( u.pos(), true );
10419 // if the monster is ridden by the player or an NPC:
10420 // Dont displace them. If they are mounted by a friendly NPC,
10421 // then the NPC will already have been displaced just above.
10422 // if they are ridden by the player, we want them to coexist on same tile
10423 if( mon && !mon->mounted_player ) {
10424 crit_name = mon->get_name();
10425 if( mon->friendly == -1 ) {
10426 mon->setpos( *displace );
10427 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10428 } else {
10429 player_displace = true;
10430 }
10431 }
10432 if( player_displace ) {
10433 u.setpos( *displace );
10434 u.moves -= 20;
10435 add_msg( _( "You push past %s blocking the way." ), crit_name );
10436 }
10437 } else {
10438 debugmsg( "Failed to find a spot to displace into." );
10439 }
10440 }
10441
10442 // Now that we know the player's destination position, we can move their mount as well
10443 if( u.is_mounted() ) {
10444 if( stored_mount ) {
10445 assert( !m.has_zlevels() );
10446 stored_mount->spawn( g->u.pos() );
10447 if( critter_tracker->add( stored_mount ) ) {
10448 u.mounted_creature = stored_mount;
10449 }
10450 } else {
10451 u.mounted_creature->setpos( g->u.pos() );
10452 }
10453 }
10454
10455 if( !npcs_to_bring.empty() ) {
10456 // Would look nicer randomly scrambled
10457 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10458 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10459 [this]( const tripoint & c ) {
10460 return !is_empty( c );
10461 } ), candidates.end() );
10462
10463 for( const auto &np : npcs_to_bring ) {
10464 const auto found = std::find_if( candidates.begin(), candidates.end(),
10465 [this, np]( const tripoint & c ) {
10466 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10467 } );
10468 if( found != candidates.end() ) {
10469 // TODO: De-uglify
10470 np->setpos( *found );
10471 np->place_on_map();
10472 np->setpos( *found );
10473 candidates.erase( found );
10474 }
10475
10476 if( candidates.empty() ) {
10477 break;
10478 }
10479 }
10480
10481 reload_npcs();
10482 }
10483
10484 // This ugly check is here because of stair teleport bullshit
10485 // TODO: Remove stair teleport bullshit
10486 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10487 for( monster *m : monsters_following ) {
10488 m->set_dest( g->u.pos() );
10489 }
10490 }
10491
10492 if( rope_ladder ) {
10493 m.ter_set( u.pos(), t_rope_up );
10494 }
10495
10496 if( m.ter( stairs ) == t_manhole_cover ) {
10497 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10498 m.ter_set( stairs, t_manhole );
10499 }
10500
10501 // Wouldn't work and may do strange things
10502 if( u.is_hauling() && !m.has_zlevels() ) {
10503 add_msg( _( "You cannot haul items here." ) );
10504 u.stop_hauling();
10505 }
10506
10507 if( u.is_hauling() ) {
10508 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10509 start_hauling( adjusted_pos );
10510 }
10511
10512 m.invalidate_map_cache( g->get_levz() );
10513 // Upon force movement, traps can not be avoided.
10514 m.creature_on_trap( u, !force );
10515
10517}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:102
@ CMM_CROUCH
Definition: character.h:104
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1535
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:882
int oxygen
Definition: character.h:1530
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1723
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8952
std::string get_name() const override
Definition: character.cpp:6095
void start_hauling(const tripoint &pos)
Definition: game.cpp:10519
cata::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10554
bool use_mech_power(int amt)
Definition: monster.cpp:2392
Character * mounted_player
Definition: monster.h:461
void set_underwater(bool)
Definition: player.cpp:516
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static const skill_id skill_melee("melee")
static cata::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:10058
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:719
ter_id t_manhole
Definition: mapdata.cpp:718
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1712
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12177
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9354
int climbing_cost(const map &m, const tripoint &from, const tripoint &to)
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4177

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), map_funcs::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 10741 of file game.cpp.

10742{
10743 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
10744 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
10745 return;
10746 }
10747
10748 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
10749 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
10750 z_before, z_after );
10751 return;
10752 }
10753 // Figure out where we know there are up/down connectors
10754 // Fill in all the tiles we know about (e.g. subway stations)
10755 static const int REVEAL_RADIUS = 40;
10756 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
10757 const tripoint_abs_omt cursp_before( p.xy(), z_before );
10758 const tripoint_abs_omt cursp_after( p.xy(), z_after );
10759
10760 if( !overmap_buffer.seen( cursp_before ) ) {
10761 continue;
10762 }
10763 if( overmap_buffer.has_note( cursp_after ) ) {
10764 // Already has a note -> never add an AUTO-note
10765 continue;
10766 }
10767 const oter_id &ter = overmap_buffer.ter( cursp_before );
10768 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
10769 if( z_after > z_before && ter->has_flag( known_up ) &&
10770 !ter2->has_flag( known_down ) ) {
10771 overmap_buffer.set_seen( cursp_after, true );
10772 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
10773 } else if( z_after < z_before && ter->has_flag( known_down ) &&
10774 !ter2->has_flag( known_up ) ) {
10775 overmap_buffer.set_seen( cursp_after, true );
10776 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
10777 }
10778 }
10779}
bool inbounds_z(const int z) const
Definition: map.h:1672
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:87
@ known_down
Definition: omdata.h:86
bool has_flag(oter_flags flag) const
Definition: omdata.h:258

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 10704 of file game.cpp.

10705{
10706 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10707 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
10708 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
10709 return;
10710 }
10711
10712 // TODO: Implement dragging stuff up/down
10713 u.grab( OBJECT_NONE );
10714
10715 scent.reset();
10716
10717 u.setz( z_after );
10718 const int z_before = get_levz();
10719 if( !m.has_zlevels() ) {
10721 m.access_cache( z_before ).vehicle_list.clear();
10722 m.access_cache( z_before ).zone_vehicles.clear();
10723 m.access_cache( z_before ).map_memory_seen_cache.reset();
10724 m.set_transparency_cache_dirty( z_before );
10725 m.set_outside_cache_dirty( z_before );
10726 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
10727 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
10728 reload_npcs();
10729 } else {
10730 // Shift the map itself
10731 m.vertical_shift( z_after );
10732 }
10733
10734 m.spawn_monsters( true );
10735 // this may be required after a vertical shift if z-levels are not enabled
10736 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
10738 vertical_notes( z_before, z_after );
10739}
void setz(int z)
Definition: character.h:794
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:10741
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.h:405
void set_outside_cache_dirty(const int zlev)
Definition: map.h:442
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:6922
std::set< vehicle * > zone_vehicles
Definition: map.h:358
std::set< vehicle * > vehicle_list
Definition: map.h:357

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 8898 of file game.cpp.

8899{
8900 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
8901 if( u.get_size() > MS_MEDIUM ) {
8902 add_msg( m_warning, _( "You can't fit there." ) );
8903 return false; // character too large to fit through a tight passage
8904 }
8905 if( u.is_mounted() ) {
8906 monster *mount = u.mounted_creature.get();
8907 if( mount->get_size() > MS_MEDIUM ) {
8908 add_msg( m_warning, _( "Your mount can't fit there." ) );
8909 return false; // char's mount is too large for tight passages
8910 }
8911 }
8912 }
8913
8914 if( u.is_mounted() ) {
8915 auto mons = u.mounted_creature.get();
8916 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
8917 if( !mons->check_mech_powered() ) {
8918 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
8919 mons->get_name() );
8920 return false;
8921 }
8922 }
8923 if( !mons->move_effects( false ) ) {
8924 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
8925 return false;
8926 }
8927 }
8928 const optional_vpart_position vp_here = m.veh_at( u.pos() );
8929 const optional_vpart_position vp_there = m.veh_at( dest_loc );
8930
8931 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
8932 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
8933 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
8934
8935 const tripoint furn_pos = u.pos() + u.grab_point;
8936 const tripoint furn_dest = dest_loc + u.grab_point;
8937
8938 bool grabbed = u.get_grab_type() != OBJECT_NONE;
8939 if( grabbed ) {
8940 const tripoint dp = dest_loc - u.pos();
8941 pushing = dp == u.grab_point;
8942 pulling = dp == -u.grab_point;
8943 }
8944 if( grabbed && dest_loc.z != u.posz() ) {
8945 add_msg( m_warning, _( "You let go of the grabbed object." ) );
8946 grabbed = false;
8947 u.grab( OBJECT_NONE );
8948 }
8949
8950 // Now make sure we're actually holding something
8951 const vehicle *grabbed_vehicle = nullptr;
8952 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
8953 // We only care about shifting, because it's the only one that can change our destination
8954 if( m.has_furn( u.pos() + u.grab_point ) ) {
8955 shifting_furniture = !pushing && !pulling;
8956 } else {
8957 // We were grabbing a furniture that isn't there
8958 grabbed = false;
8959 }
8960 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
8961 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
8962 if( grabbed_vehicle == nullptr ) {
8963 // We were grabbing a vehicle that isn't there anymore
8964 grabbed = false;
8965 }
8966 } else if( grabbed ) {
8967 // We were grabbing something WEIRD, let's pretend we weren't
8968 grabbed = false;
8969 }
8970 if( u.grab_point != tripoint_zero && !grabbed ) {
8971 add_msg( m_warning, _( "Can't find grabbed object." ) );
8972 u.grab( OBJECT_NONE );
8973 }
8974
8975 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
8976 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
8977 vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
8978 tripoint diff = dest_loc - u.pos();
8979 if( diff.x < 0 ) {
8980 diff.x -= 2;
8981 } else if( diff.x > 0 ) {
8982 diff.x += 2;
8983 }
8984 if( diff.y < 0 ) {
8985 diff.y -= 2;
8986 } else if( diff.y > 0 ) {
8987 diff.y += 2;
8988 }
8989 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
8990 dest_loc );
8991 }
8992 return false;
8993 }
8994 if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
8995 return false;
8996 }
8997 if( u.is_mounted() && !pushing && vp_there ) {
8998 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
8999 return false;
9000 }
9001 u.set_underwater( false );
9002
9003 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
9004 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9005 const auto dangerous_terrain_opt = get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" );
9006 const auto harmful_text = enumerate_as_string( harmful_stuff );
9007 const auto warn_msg = [&]( const char *const msg ) {
9008 add_msg( m_warning, msg, harmful_text );
9009 };
9010
9011 if( dangerous_terrain_opt == "IGNORE" ) {
9012 warn_msg( _( "Stepping into that %1$s looks risky, but you enter anyway." ) );
9013 } else if( dangerous_terrain_opt == "ALWAYS" && !prompt_dangerous_tile( dest_loc ) ) {
9014 return true;
9015 } else if( dangerous_terrain_opt == "RUNNING" &&
9016 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9017 warn_msg( _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ) );
9018 return true;
9019 } else if( dangerous_terrain_opt == "CROUCHING" &&
9020 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9021 warn_msg( _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ) );
9022 return true;
9023 } else if( dangerous_terrain_opt == "NEVER" && !u.movement_mode_is( CMM_RUN ) ) {
9024 warn_msg( _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ) );
9025 return true;
9026 }
9027 }
9028 // Used to decide whether to print a 'moving is slow message
9029 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
9030
9031 int modifier = 0;
9032 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
9033 modifier = -m.furn( dest_loc ).obj().movecost;
9034 }
9035
9036 int multiplier = 1;
9037 if( u.is_on_ground() ) {
9038 multiplier *= 3;
9039 }
9040
9041 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
9042 via_ramp ) * multiplier;
9043 if( grabbed_move( dest_loc - u.pos() ) ) {
9044 return true;
9045 } else if( mcost == 0 ) {
9046 return false;
9047 }
9048 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
9049 const int previous_moves = u.moves;
9050 if( u.is_mounted() ) {
9051 auto crit = u.mounted_creature.get();
9052 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
9053 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
9054 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
9055 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
9056 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
9057 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
9058 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
9059 return false;
9060 }
9061 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
9062 const double encumb_moves = u.get_weight() / 4800.0_gram;
9063 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
9064 if( u.movement_mode_is( CMM_WALK ) ) {
9065 crit->use_mech_power( -2 );
9066 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9067 crit->use_mech_power( -1 );
9068 } else if( u.movement_mode_is( CMM_RUN ) ) {
9069 crit->use_mech_power( -3 );
9070 }
9071 } else {
9072 u.moves -= u.run_cost( mcost, diag );
9073 /**
9074 TODO:
9075 This should really use the mounted creatures stamina, if mounted.
9076 Monsters don't currently have stamina however.
9077 For the time being just don't burn players stamina when mounted.
9078 */
9079 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
9080 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
9081 u.burn_move_stamina( previous_moves - u.moves );
9082 } else {
9083 //Burn half as much stamina if vehicle has wheels, without changing move time
9084 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
9085 }
9086 }
9087 // Max out recoil & reset aim point
9090
9091 // Print a message if movement is slow
9092 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
9093 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
9094 m.has_flag_ter_or_furn( "FUNGUS",
9095 dest_loc ); //fungal furniture has no slowing effect on mycus characters
9096 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
9097 mcost_to > 4 || mcost_from > 4 ) &&
9098 !( u.has_trait( trait_M_IMMUNE ) && fungus );
9099 if( slowed && !u.is_mounted() ) {
9100 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
9101 if( mcost_to >= mcost_from ) {
9102 if( auto displayed_part = vp_there.part_displayed() ) {
9103 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
9104 displayed_part->part().name() );
9105 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9106 } else {
9107 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
9108 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
9109 }
9110 } else {
9111 if( auto displayed_part = vp_here.part_displayed() ) {
9112 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
9113 displayed_part->part().name() );
9114 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9115 } else {
9116 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
9117 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
9118 }
9119 }
9120 }
9121 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
9122 ( !u.footwear_factor() ||
9123 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
9124 // DX and IN are long suits for Cephalopods,
9125 // so this shouldn't cause too much hardship
9126 // Presumed that if it's swimmable, they're
9127 // swimming and won't stick
9128 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
9129
9130 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
9131 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9132 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9133 u.mod_fatigue( 1 );
9134 }
9135 }
9136 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9137 int volume = u.is_stealthy() ? 3 : 6;
9138 volume *= u.mutation_value( "noise_modifier" );
9139 if( volume > 0 ) {
9141 volume = 2;
9142 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9143 volume = 12;
9144 }
9145 if( u.movement_mode_is( CMM_RUN ) ) {
9146 volume *= 1.5;
9147 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9148 volume /= 2;
9149 }
9150 if( u.is_mounted() ) {
9151 auto mons = u.mounted_creature.get();
9152 switch( mons->get_size() ) {
9153 case MS_TINY:
9154 volume = 0; // No sound for the tinies
9155 break;
9156 case MS_SMALL:
9157 volume /= 3;
9158 break;
9159 case MS_MEDIUM:
9160 break;
9161 case MS_LARGE:
9162 volume *= 1.5;
9163 break;
9164 case MS_HUGE:
9165 volume *= 2;
9166 break;
9167 default:
9168 break;
9169 }
9170 if( mons->has_flag( MF_LOUDMOVES ) ) {
9171 volume += 6;
9172 }
9173 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9174 "none", "none" );
9175 } else {
9176 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9177 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9178 }
9180 }
9181
9182 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9183 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9184 "misc", "rattling" );
9185 }
9186 }
9187
9188 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9189 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9190 }
9191
9192 if( dest_loc != u.pos() ) {
9194 }
9195
9196 tripoint oldpos = u.pos();
9197 point submap_shift = place_player( dest_loc );
9198 point ms_shift = sm_to_ms_copy( submap_shift );
9199 oldpos = oldpos - ms_shift;
9200
9201 if( pulling ) {
9202 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9203 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9204 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9205 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9206 m.remove_field( shifted_furn_pos, fd_fire );
9207 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9208 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9209 }
9210
9211 if( u.is_hauling() ) {
9212 start_hauling( oldpos );
9213 }
9214
9216
9217 return true;
9218}
void burn_move_stamina(int moves)
Definition: character.cpp:7223
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3220
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3664
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:962
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6751
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:541
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3240
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:9824
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8827
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1838
m_size get_size() const override
Definition: monster.cpp:2692
cata::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2498
bool is_stealthy() const
Returns true if the player has stealthy movement.
cata::optional< tripoint > last_target_pos
Definition: player.h:598
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2194
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1635
void do_footstep()
Definition: sounds.cpp:1612

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2535 of file game.cpp.

2536{
2537 win_screen();
2539 memorial().add(
2540 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2541 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2542 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2543 if( !u.is_dead_state() ) {
2546 }
2547}
void win_screen()
Definition: game.cpp:2549
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2549 of file game.cpp.

2550{
2551 // TODO: Move this wall somewhere
2553 std::string msg = _( "You managed to close the portal and end the invasion!" );
2554 msg += '\n';
2555 if( u.is_dead_state() ) {
2557 "Unfortunately, you had to sacrifice your life to achieve this." );
2558 msg += colorize( t, c_red ) + '\n';
2559 memorial().add(
2560 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2561 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2562 } else {
2563 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2564 msg += colorize( t, c_green ) + '\n';
2565 memorial().add(
2566 pgettext( "memorial_male", "Safely closed the portal." ),
2567 pgettext( "memorial_female", "Safely closed the portal." ) );
2568 }
2569 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2570 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2571 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2572 popup( msg );
2573}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 2939 of file game.cpp.

2940{
2941 const std::string &memorial_dir = PATH_INFO::memorialdir();
2942 const std::string &memorial_active_world_dir = memorial_dir +
2943 world_generator->active_world->world_name + "/";
2944
2945 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
2946 if( !assure_dir_exist( memorial_dir ) ) {
2947 debugmsg( "Could not make '%s' directory", memorial_dir );
2948 return;
2949 }
2950
2951 if( !assure_dir_exist( memorial_active_world_dir ) ) {
2952 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
2953 return;
2954 }
2955
2956 std::string path = memorial_active_world_dir + filename + ".txt";
2957
2958 write_to_file( path, [&]( std::ostream & fout ) {
2959 memorial().write( fout, sLastWords );
2960 }, _( "player memorial" ) );
2961}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:226

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6237 of file game.cpp.

6238{
6239 const tripoint stored_view_offset = u.view_offset;
6240
6242
6243 const int zone_ui_height = 12;
6244 const int zone_options_height = 7;
6245
6246 const int width = 45;
6247
6248 int offsetX = 0;
6249 int max_rows = 0;
6250
6251 catacurses::window w_zones;
6252 catacurses::window w_zones_border;
6253 catacurses::window w_zones_info;
6254 catacurses::window w_zones_info_border;
6255 catacurses::window w_zones_options;
6256
6257 bool show = true;
6258
6259 ui_adaptor ui;
6260 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6261 if( !show ) {
6262 ui.position( point_zero, point_zero );
6263 return;
6264 }
6265 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6266 TERMX - width : 0;
6267 const int w_zone_height = TERMY - zone_ui_height;
6268 max_rows = w_zone_height - 2;
6269 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6270 point( offsetX + 1, 1 ) );
6271 w_zones_border = catacurses::newwin( w_zone_height, width,
6272 point( offsetX, 0 ) );
6273 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6274 width - 2, point( offsetX + 1, w_zone_height ) );
6275 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6276 point( offsetX, w_zone_height ) );
6277 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6278 point( offsetX + 1, TERMY - zone_options_height ) );
6279
6280 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6281 } );
6282 ui.mark_resize();
6283
6284 std::string action;
6285 input_context ctxt( "ZONES_MANAGER" );
6286 ctxt.register_cardinal();
6287 ctxt.register_action( "CONFIRM" );
6288 ctxt.register_action( "QUIT" );
6289 ctxt.register_action( "ADD_ZONE" );
6290 ctxt.register_action( "REMOVE_ZONE" );
6291 ctxt.register_action( "MOVE_ZONE_UP" );
6292 ctxt.register_action( "MOVE_ZONE_DOWN" );
6293 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6294 ctxt.register_action( "ENABLE_ZONE" );
6295 ctxt.register_action( "DISABLE_ZONE" );
6296 ctxt.register_action( "SHOW_ALL_ZONES" );
6297 ctxt.register_action( "HELP_KEYBINDINGS" );
6298
6299 auto &mgr = zone_manager::get_manager();
6300 int start_index = 0;
6301 int active_index = 0;
6302 bool blink = false;
6303 bool stuff_changed = false;
6304 bool show_all_zones = false;
6305 int zone_cnt = 0;
6306
6307 // get zones on the same z-level, with distance between player and
6308 // zone center point <= 50 or all zones, if show_all_zones is true
6309 auto get_zones = [&]() {
6310 std::vector<zone_manager::ref_zone_data> zones;
6311 if( show_all_zones ) {
6312 zones = mgr.get_zones();
6313 } else {
6314 const tripoint &u_abs_pos = m.getabs( u.pos() );
6315 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6316 const tripoint &zone_abs_pos = ref.get().get_center_point();
6317 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6318 zones.emplace_back( ref );
6319 }
6320 }
6321 }
6322 zone_cnt = static_cast<int>( zones.size() );
6323 return zones;
6324 };
6325
6326 auto zones = get_zones();
6327
6328 auto zones_manager_options = [&]() {
6329 werase( w_zones_options );
6330
6331 if( zone_cnt > 0 ) {
6332 const auto &zone = zones[active_index].get();
6333
6334 if( zone.has_options() ) {
6335 const auto &descriptions = zone.get_options().get_descriptions();
6336
6337 // NOLINTNEXTLINE(cata-use-named-point-constants)
6338 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6339
6340 int y = 1;
6341 for( const auto &desc : descriptions ) {
6342 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6343 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6344 y++;
6345 }
6346 }
6347 }
6348
6349 wnoutrefresh( w_zones_options );
6350 };
6351
6352 cata::optional<tripoint> zone_start;
6353 cata::optional<tripoint> zone_end;
6354 bool zone_blink = false;
6355 bool zone_cursor = false;
6357 zone_start, zone_end, zone_blink, zone_cursor );
6358 add_draw_callback( zone_cb );
6359
6360 auto query_position =
6361 [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
6362 on_out_of_scope invalidate_current_ui( [&]()
6363 {
6364 ui.mark_resize();
6365 } );
6366 restore_on_out_of_scope<bool> show_prev( show );
6367 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6368 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6369 show = false;
6370 zone_start = cata::nullopt;
6371 zone_end = cata::nullopt;
6372 ui.mark_resize();
6373
6375 popup.on_top( true );
6376 popup.message( "%s", _( "Select first point." ) );
6377
6379
6380 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6381 false );
6382 if( first.position )
6383 {
6384 popup.message( "%s", _( "Select second point." ) );
6385
6386 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6387 true, true, false );
6388 if( second.position ) {
6389 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6390 second.position->x ),
6391 std::min( first.position->y, second.position->y ),
6392 std::min( first.position->z,
6393 second.position->z ) ) );
6394 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6395 second.position->x ),
6396 std::max( first.position->y, second.position->y ),
6397 std::max( first.position->z,
6398 second.position->z ) ) );
6399 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6400 }
6401 }
6402
6403 return cata::nullopt;
6404 };
6405
6406 ui.on_redraw( [&]( const ui_adaptor & ) {
6407 if( !show ) {
6408 return;
6409 }
6410 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6411 zones_manager_shortcuts( w_zones_info );
6412
6413 if( zone_cnt == 0 ) {
6414 werase( w_zones );
6415 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6416
6417 } else {
6418 werase( w_zones );
6419
6420 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6421
6422 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6423 wnoutrefresh( w_zones_border );
6424
6425 int iNum = 0;
6426
6427 tripoint player_absolute_pos = m.getabs( u.pos() );
6428
6429 //Display saved zones
6430 for( auto &i : zones ) {
6431 if( iNum >= start_index &&
6432 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6433 const auto &zone = i.get();
6434
6435 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6436
6437 if( iNum == active_index ) {
6438 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6439 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6440 }
6441
6442 //Draw Zone name
6443 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6444 trim_by_length( zone.get_name(), 15 ) );
6445
6446 //Draw Type name
6447 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6448 mgr.get_name_from_type( zone.get_type() ) );
6449
6450 tripoint center = zone.get_center_point();
6451
6452 //Draw direction + distance
6453 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6454 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6455 direction_name_short( direction_from( player_absolute_pos,
6456 center ) ) );
6457
6458 //Draw Vehicle Indicator
6459 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6460 zone.get_is_vehicle() ? "*" : "" );
6461 }
6462 iNum++;
6463 }
6464
6465 // Display zone options
6466 zones_manager_options();
6467 }
6468
6469 wnoutrefresh( w_zones );
6470 } );
6471
6472 zones_manager_open = true;
6473 do {
6474 if( action == "ADD_ZONE" ) {
6475 do { // not a loop, just for quick bailing out if canceled
6476 const auto maybe_id = mgr.query_type();
6477 if( !maybe_id.has_value() ) {
6478 break;
6479 }
6480
6481 const zone_type_id &id = maybe_id.value();
6482 auto options = zone_options::create( id );
6483
6484 if( !options->query_at_creation() ) {
6485 break;
6486 }
6487
6488 auto default_name = options->get_zone_name_suggestion();
6489 if( default_name.empty() ) {
6490 default_name = mgr.get_name_from_type( id );
6491 }
6492 const auto maybe_name = mgr.query_name( default_name );
6493 if( !maybe_name.has_value() ) {
6494 break;
6495 }
6496 const std::string &name = maybe_name.value();
6497
6498 const auto position = query_position();
6499 if( !position ) {
6500 break;
6501 }
6502
6503 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6504 position->second, options );
6505
6506 zones = get_zones();
6507 active_index = zone_cnt - 1;
6508
6509 stuff_changed = true;
6510 } while( false );
6511
6512 blink = false;
6513 } else if( action == "SHOW_ALL_ZONES" ) {
6514 show_all_zones = !show_all_zones;
6515 zones = get_zones();
6516 active_index = 0;
6517 } else if( zone_cnt > 0 ) {
6518 if( action == "UP" ) {
6519 active_index--;
6520 if( active_index < 0 ) {
6521 active_index = zone_cnt - 1;
6522 }
6523 blink = false;
6524 } else if( action == "DOWN" ) {
6525 active_index++;
6526 if( active_index >= zone_cnt ) {
6527 active_index = 0;
6528 }
6529 blink = false;
6530 } else if( action == "REMOVE_ZONE" ) {
6531 if( active_index < zone_cnt ) {
6532 mgr.remove( zones[active_index] );
6533 zones = get_zones();
6534 active_index--;
6535
6536 if( active_index < 0 ) {
6537 active_index = 0;
6538 }
6539 }
6540 blink = false;
6541 stuff_changed = true;
6542
6543 } else if( action == "CONFIRM" ) {
6544 auto &zone = zones[active_index].get();
6545
6546 uilist as_m;
6547 as_m.text = _( "What do you want to change:" );
6548 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6549 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6550 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6551 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6552 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6553 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6554 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6555 as_m.query();
6556
6557 switch( as_m.ret ) {
6558 case 1:
6559 if( zone.set_name() ) {
6560 stuff_changed = true;
6561 }
6562 break;
6563 case 2:
6564 if( zone.set_type() ) {
6565 stuff_changed = true;
6566 }
6567 break;
6568 case 3:
6569 if( zone.get_options().query() ) {
6570 stuff_changed = true;
6571 }
6572 break;
6573 case 4: {
6574 const auto pos = query_position();
6575 if( pos && ( pos->first != zone.get_start_point() ||
6576 pos->second != zone.get_end_point() ) ) {
6577 zone.set_position( *pos );
6578 stuff_changed = true;
6579 }
6580 break;
6581 }
6582 case 5: {
6583 on_out_of_scope invalidate_current_ui( [&]() {
6584 ui.mark_resize();
6585 } );
6586 restore_on_out_of_scope<bool> show_prev( show );
6587 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6588 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6589 show = false;
6590 zone_start = cata::nullopt;
6591 zone_end = cata::nullopt;
6592 ui.mark_resize();
6593 static_popup message_pop;
6594 message_pop.on_top( true );
6595 message_pop.message( "%s", _( "Moving zone." ) );
6596 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6597 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6598 // local position of the zone center, used to calculate the u.view_offset,
6599 // could center the screen to the position it represents
6600 auto view_center = m.getlocal( zone.get_center_point() );
6601 const look_around_result result_local = look_around( false, view_center,
6602 zone_local_start_point, false, false,
6603 false, true, zone_local_end_point );
6604 if( result_local.position ) {
6605 const auto new_start_point = m.getabs( *result_local.position );
6606 if( new_start_point == zone.get_start_point() ) {
6607 break; // Nothing changed, don't save
6608 }
6609
6610 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6611 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6612 stuff_changed = true;
6613 }
6614 }
6615 break;
6616 default:
6617 break;
6618 }
6619
6620 blink = false;
6621 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6622 if( active_index < zone_cnt - 1 ) {
6623 mgr.swap( zones[active_index], zones[active_index + 1] );
6624 zones = get_zones();
6625 active_index++;
6626 }
6627 blink = false;
6628 stuff_changed = true;
6629
6630 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6631 if( active_index > 0 ) {
6632 mgr.swap( zones[active_index], zones[active_index - 1] );
6633 zones = get_zones();
6634 active_index--;
6635 }
6636 blink = false;
6637 stuff_changed = true;
6638
6639 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6640 //show zone position on overmap;
6641 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6642 // TODO: fix point types
6643 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6644
6645 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6646 } else if( action == "ENABLE_ZONE" ) {
6647 zones[active_index].get().set_enabled( true );
6648
6649 stuff_changed = true;
6650
6651 } else if( action == "DISABLE_ZONE" ) {
6652 zones[active_index].get().set_enabled( false );
6653
6654 stuff_changed = true;
6655 }
6656 }
6657
6658 if( zone_cnt > 0 ) {
6659 blink = !blink;
6660 const auto &zone = zones[active_index].get();
6661 zone_start = m.getlocal( zone.get_start_point() );
6662 zone_end = m.getlocal( zone.get_end_point() );
6663 ctxt.set_timeout( BLINK_SPEED );
6664 } else {
6665 blink = false;
6666 zone_start = zone_end = cata::nullopt;
6667 ctxt.reset_timeout();
6668 }
6669
6670 // Actually accessed from the terrain overlay callback `zone_cb` in the
6671 // call to `ui_manager::redraw`.
6672 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6673 zone_blink = blink;
6675
6677
6678 //Wait for input
6679 action = ctxt.handle_input();
6680 } while( action != "QUIT" );
6681 zones_manager_open = false;
6682 ctxt.reset_timeout();
6683 zone_cb = nullptr;
6684
6685 if( stuff_changed ) {
6686 auto &zones = zone_manager::get_manager();
6687 if( query_yn( _( "Save changes?" ) ) ) {
6688 zones.save_zones();
6689 } else {
6690 zones.load_zones();
6691 }
6692
6693 zones.cache_data();
6694 }
6695
6696 u.view_offset = stored_view_offset;
6697}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:342
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:186
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6172
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6195
std::string options()
Definition: path_info.cpp:238
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
cata::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7199 of file game.cpp.

7200{
7201#if defined(TILES)
7202 if( tileset_zoom == 64 ) {
7203 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7204 } else {
7206 }
7207 rescale_tileset( tileset_zoom );
7208#endif
7209}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7187 of file game.cpp.

7188{
7189#if defined(TILES)
7190 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7192 } else {
7193 tileset_zoom = 64;
7194 }
7195 rescale_tileset( tileset_zoom );
7196#endif
7197}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 103 of file avatar.cpp.

104{
105 return g->u;
106}

Referenced by butcher_submenu().

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12193 of file game.cpp.

12194{
12195 return *g->grid_tracker_ptr;
12196}

◆ get_map

map & get_map ( )
friend

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 387 of file character.cpp.

388{
389 return g->u;
390}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 981 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1044 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1061 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1075 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1025 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1026 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1038 of file game.h.

◆ displaying_overlays

cata::optional<action_id> game::displaying_overlays
private

Definition at line 945 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1036 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 1023 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 979 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1077 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 985 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 982 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1094 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1096 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1095 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1067 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1068 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1058 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1057 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 976 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 975 of file game.h.

◆ m

map& game::m

Definition at line 989 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), delete_cyborg_item(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 973 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 983 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 1010 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1066 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1006 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1064 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1062 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1073 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1045 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1071 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1070 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1041 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1060 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen

Definition at line 1008 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 991 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 977 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1089 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1056 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1040 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 984 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 980 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 1012 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1086 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 978 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 992 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 1001 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1047 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 990 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), death_screen(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), toggle_gate(), try_get_left_click_action(), try_get_right_click_action(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 974 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1051 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 1004 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1083 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 1016 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1054 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 1015 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 1014 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1053 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1102 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1043 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 986 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1079 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: